[dpdk-dev] [PATCH] test/compress: unit tests refactoring

[dpdk-dev] [PATCH] test/compress: unit tests refactoring

[Artur Trybula]

Core engine refactoring (test_deflate_comp_decomp function).
Smaller specialized functions created.

Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
---
This patch depends on "test/compress: unit test for stateless
overflow recovery": http://patches.dpdk.org/patch/58834/

 app/test/test_compressdev.c | 833 +++++++++++++++++++++++++++---------
 1 file changed, 630 insertions(+), 203 deletions(-)

diff --git a/app/test/test_compressdev.c b/app/test/test_compressdev.c
index 3a655164f..2bb164a37 100644
--- a/app/test/test_compressdev.c
+++ b/app/test/test_compressdev.c
@@ -110,6 +110,16 @@ struct test_data_params {
 	enum overflow_test overflow;
 };
 
+struct test_private_arrays {
+	struct rte_mbuf **uncomp_bufs;
+	struct rte_mbuf **comp_bufs;
+	struct rte_comp_op **ops;
+	struct rte_comp_op **ops_processed;
+	void **priv_xforms;
+	uint64_t *compress_checksum;
+	uint32_t *compressed_data_size;
+};
+
 static struct comp_testsuite_params testsuite_params = { 0 };
 
 static void
@@ -721,8 +731,9 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf,
 
 
 static int
-test_run_enqueue_dequeue(struct rte_comp_op **ops, unsigned int num_bufs,
-		  struct rte_comp_op **ops_processed)
+test_run_enqueue_dequeue(struct rte_comp_op **ops,
+			 struct rte_comp_op **ops_processed,
+			 unsigned int num_bufs)
 {
 	uint16_t num_enqd, num_deqd, num_total_deqd;
 	unsigned int deqd_retries = 0;
@@ -763,66 +774,70 @@ test_run_enqueue_dequeue(struct rte_comp_op **ops, unsigned int num_bufs,
 	return 0;
 }
 
-/*
- * Compresses and decompresses buffer with compressdev API and Zlib API
+/**
+ * Initialize all the arrays used in comp/decomp to NULL.
+ *
+ * If the length is greater than the length of the last segment, the
+ * function will fail and return -1 without modifying the mbuf.
+ *
+ * @param priv_arrays
+ *   A container used for aggregation all the arrays.
+ * @param num_bufs
+ *   The number of elements in each array.
+ */
+static void
+test_objects_init(struct test_private_arrays *prv,
+		unsigned int num_bufs)
+{
+	/* Initialize all arrays to NULL */
+	memset(prv->uncomp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
+	memset(prv->comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
+	memset(prv->ops, 0, sizeof(struct rte_comp_op *) * num_bufs);
+	memset(prv->ops_processed, 0, sizeof(struct rte_comp_op *) * num_bufs);
+	memset(prv->priv_xforms, 0, sizeof(void *) * num_bufs);
+	memset(prv->compressed_data_size, 0, sizeof(uint32_t) * num_bufs);
+}
+
+/**
+ * Source buffers preparation (for compression).
+ *
+ * Memory allocation for each buffer from mempool
+ * -1 returned if function fail, without modifying the mbuf.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
  */
 static int
-test_deflate_comp_decomp(const struct interim_data_params *int_data,
-		const struct test_data_params *test_data)
+test_mbufs_source_preparation(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
 {
+	/* local variables: */
+	unsigned int i;
+	uint32_t data_size;
+	char *buf_ptr;
+	int ret;
+
 	struct comp_testsuite_params *ts_params = &testsuite_params;
+
+	/* from int_data: */
 	const char * const *test_bufs = int_data->test_bufs;
 	unsigned int num_bufs = int_data->num_bufs;
-	uint16_t *buf_idx = int_data->buf_idx;
-	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
-	struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms;
-	unsigned int num_xforms = int_data->num_xforms;
-	enum rte_comp_op_type state = test_data->state;
+
+	/* from test_data: */
 	unsigned int buff_type = test_data->buff_type;
-	unsigned int out_of_space = test_data->out_of_space;
 	unsigned int big_data = test_data->big_data;
-	enum zlib_direction zlib_dir = test_data->zlib_dir;
-	enum overflow_test overflow_tst = test_data->overflow;
-	int ret_status = -1;
-	int ret;
-	struct rte_mbuf *uncomp_bufs[num_bufs];
-	struct rte_mbuf *comp_bufs[num_bufs];
-	struct rte_comp_op *ops[num_bufs];
-	struct rte_comp_op *ops_processed[num_bufs];
-	void *priv_xforms[num_bufs];
-	uint16_t num_enqd, num_deqd, num_total_deqd;
-	uint16_t num_priv_xforms = 0;
-	unsigned int deqd_retries = 0;
-	struct priv_op_data *priv_data;
-	char *buf_ptr;
-	unsigned int i;
-	struct rte_mempool *buf_pool;
-	uint32_t data_size;
-	/* Compressing with CompressDev */
-	unsigned int oos_zlib_decompress =
-			(zlib_dir == ZLIB_NONE || zlib_dir == ZLIB_DECOMPRESS);
-	/* Decompressing with CompressDev */
-	unsigned int oos_zlib_compress =
-			(zlib_dir == ZLIB_NONE || zlib_dir == ZLIB_COMPRESS);
-	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];
-	uint32_t compressed_data_size[num_bufs];
 
-	if (capa == NULL) {
-		RTE_LOG(ERR, USER1,
-			"Compress device does not support DEFLATE\n");
-		return -1;
-	}
-
-	/* Initialize all arrays to NULL */
-	memset(uncomp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
-	memset(comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
-	memset(ops, 0, sizeof(struct rte_comp_op *) * num_bufs);
-	memset(ops_processed, 0, sizeof(struct rte_comp_op *) * num_bufs);
-	memset(priv_xforms, 0, sizeof(void *) * num_bufs);
-	memset(compressed_data_size, 0, sizeof(uint32_t) * num_bufs);
+	/* from priv_arrays: */
+	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
+	struct rte_mempool *buf_pool;
 
 	if (big_data)
 		buf_pool = ts_params->big_mbuf_pool;
@@ -831,14 +846,15 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	else
 		buf_pool = ts_params->large_mbuf_pool;
 
-	/* Prepare the source mbufs with the data */
+	/* for compression uncomp_bufs is used as a source buffer */
+	/* allocation from buf_pool (mempool type) */
 	ret = rte_pktmbuf_alloc_bulk(buf_pool,
 				uncomp_bufs, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Source mbufs could not be allocated "
 			"from the mempool\n");
-		goto exit;
+		return -1;
 	}
 
 	if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
@@ -850,7 +866,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 			    big_data ? buf_pool : ts_params->large_mbuf_pool,
 			    big_data ? 0 : MAX_SEGS,
 			    big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) < 0)
-				goto exit;
+				return -1;
 		}
 	} else {
 		for (i = 0; i < num_bufs; i++) {
@@ -860,68 +876,194 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 			if (buf_ptr == NULL) {
 				RTE_LOG(ERR, USER1,
 					"Append extra bytes to the source mbuf failed\n");
-				goto exit;
+				return -1;
 			}
 			strlcpy(buf_ptr, test_bufs[i], data_size);
 		}
 	}
 
-	/* Prepare the destination mbufs */
-	ret = rte_pktmbuf_alloc_bulk(buf_pool, comp_bufs, num_bufs);
+	return 0;
+}
+
+/**
+ * Memory buffers preparation (for both compression and decompression).
+ *
+ * Memory allocation for comp/decomp buffers from mempool, depending on
+ * ops_processed value. Developer is requested to provide input params
+ * according to the following rule:
+ *      if ops_processed == NULL -> current_bufs = comp_bufs[]
+ *      if ops_processed != NULL -> current_bufs = decomp_bufs[]
+ * -1 returned if function fail, without modifying the mbuf.
+ *
+ * @param ops_processed
+ *   Operations created as a result of compression phase. Should be
+ *   set to NULL for compression
+ * @param current_bufs
+ *   mbufs being prepared in the function.
+ * @param out_of_space_and_zlib
+ *   Boolean value to switch into "out of space" buffer if set.
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_mbufs_destination_preparation(
+		struct rte_comp_op *ops_processed[], /*can be equal to NULL*/
+		struct rte_mbuf *current_bufs[],
+		unsigned int out_of_space_and_zlib,
+		const struct interim_data_params *int_data,
+		const struct test_data_params *test_data)
+{
+	/* local variables: */
+	unsigned int i;
+	uint32_t data_size;
+	struct priv_op_data *priv_data;
+	int ret;
+	char *buf_ptr;
+
+	struct comp_testsuite_params *ts_params = &testsuite_params;
+
+	/* from int_data: */
+	const char * const *test_bufs = int_data->test_bufs;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from test_data: */
+	unsigned int buff_type = test_data->buff_type;
+	unsigned int big_data = test_data->big_data;
+
+	/* from priv_arrays: */
+	struct rte_mempool *buf_pool;
+
+	if (big_data)
+		buf_pool = ts_params->big_mbuf_pool;
+	else if (buff_type == SGL_BOTH)
+		buf_pool = ts_params->small_mbuf_pool;
+	else
+		buf_pool = ts_params->large_mbuf_pool;
+
+	/* the mbufs allocation*/
+	ret = rte_pktmbuf_alloc_bulk(buf_pool, current_bufs, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Destination mbufs could not be allocated "
 			"from the mempool\n");
-		goto exit;
+		return -1;
 	}
 
-	if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
-		for (i = 0; i < num_bufs; i++) {
-			if (out_of_space == 1 && oos_zlib_decompress)
-				data_size = OUT_OF_SPACE_BUF;
-			else
-				(data_size = strlen(test_bufs[i]) *
-					COMPRESS_BUF_SIZE_RATIO);
-
-			if (prepare_sgl_bufs(NULL, comp_bufs[i],
-			      data_size,
-			      big_data ? buf_pool : ts_params->small_mbuf_pool,
-			      big_data ? buf_pool : ts_params->large_mbuf_pool,
-			      big_data ? 0 : MAX_SEGS,
-			      big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE)
-					< 0)
-				goto exit;
-		}
+	for (i = 0; i < num_bufs; i++) {
 
-	} else {
-		for (i = 0; i < num_bufs; i++) {
-			if (out_of_space == 1 && oos_zlib_decompress)
-				data_size = OUT_OF_SPACE_BUF;
-			else {
+		/* data size calculation */
+		if (out_of_space_and_zlib)
+			data_size = OUT_OF_SPACE_BUF;
+		else {
+			if (ops_processed == NULL) {
 				float ratio =
 				((test_data->zlib_dir == ZLIB_DECOMPRESS ||
-				   test_data->zlib_dir == ZLIB_NONE) &&
-				  overflow_tst == OVERFLOW_ENABLED) ?
+				  test_data->zlib_dir == ZLIB_NONE) &&
+				  test_data->overflow == OVERFLOW_ENABLED) ?
 					 COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
 					 COMPRESS_BUF_SIZE_RATIO;
 
+				printf("ratio %2.2f\n", ratio);
 				data_size = strlen(test_bufs[i]) * ratio;
+
+			} else {
+				priv_data = (struct priv_op_data *)
+					(ops_processed[i] + 1);
+				data_size =
+					strlen(test_bufs[priv_data->orig_idx])
+					+ 1;
 			}
-			buf_ptr = rte_pktmbuf_append(comp_bufs[i], data_size);
+		}
+
+		/* data allocation */
+		if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
+			ret = prepare_sgl_bufs(NULL, current_bufs[i],
+			      data_size,
+			      big_data ? buf_pool : ts_params->small_mbuf_pool,
+			      big_data ? buf_pool : ts_params->large_mbuf_pool,
+			      big_data ? 0 : MAX_SEGS,
+			      big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE);
+			if (ret < 0)
+				return -1;
+		} else {
+			buf_ptr = rte_pktmbuf_append(current_bufs[i],
+					data_size);
 			if (buf_ptr == NULL) {
 				RTE_LOG(ERR, USER1,
 					"Append extra bytes to the destination mbuf failed\n");
-				goto exit;
+				return -1;
 			}
 		}
 	}
 
+	return 0;
+}
+
+/**
+ * The main compression function.
+ *
+ * Operation(s) configuration, depending on CLI parameters.
+ * Operation(s) processing.
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_comp_run(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
+{
+	/* local variables: */
+	struct priv_op_data *priv_data;
+	unsigned int i;
+	uint16_t num_priv_xforms = 0;
+	int ret;
+	int ret_status = 0;
+	char *buf_ptr;
+
+	struct comp_testsuite_params *ts_params = &testsuite_params;
+
+	/* from test_data: */
+	enum rte_comp_op_type operation_type = test_data->state;
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+
+	/* from int_data: */
+	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
+	unsigned int num_xforms = int_data->num_xforms;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from priv_arrays: */
+	struct rte_mbuf **comp_bufs = priv_arrays->comp_bufs;
+	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
+	struct rte_comp_op **ops = priv_arrays->ops;
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
+	void **priv_xforms = priv_arrays->priv_xforms;
+
+	const struct rte_compressdev_capabilities *capa =
+		rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
+
 	/* Build the compression operations */
 	ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Compress operations could not be allocated "
 			"from the mempool\n");
+		ret_status = -1;
 		goto exit;
 	}
 
@@ -931,12 +1073,13 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		ops[i]->src.offset = 0;
 		ops[i]->src.length = rte_pktmbuf_pkt_len(uncomp_bufs[i]);
 		ops[i]->dst.offset = 0;
-		if (state == RTE_COMP_OP_STATELESS) {
+		if (operation_type == RTE_COMP_OP_STATELESS) {
 			ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
 		} else {
 			RTE_LOG(ERR, USER1,
 				"Stateful operations are not supported "
 				"in these tests yet\n");
+			ret_status = -1;
 			goto exit;
 		}
 		ops[i]->input_chksum = 0;
@@ -951,14 +1094,16 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	}
 
 	/* Compress data (either with Zlib API or compressdev API */
-	if (zlib_dir == ZLIB_COMPRESS || zlib_dir == ZLIB_ALL) {
+	if (zlib_compress) {
 		for (i = 0; i < num_bufs; i++) {
 			const struct rte_comp_xform *compress_xform =
 				compress_xforms[i % num_xforms];
 			ret = compress_zlib(ops[i], compress_xform,
 					DEFAULT_MEM_LEVEL);
-			if (ret < 0)
+			if (ret < 0) {
+				ret_status = -1;
 				goto exit;
+			}
 
 			ops_processed[i] = ops[i];
 		}
@@ -972,11 +1117,11 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 				RTE_LOG(ERR, USER1,
 					"Compression private xform "
 					"could not be created\n");
+				ret_status = -1;
 				goto exit;
 			}
 			num_priv_xforms++;
 		}
-
 		if (capa->comp_feature_flags & RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
 			/* Attach shareable private xform data to ops */
 			for (i = 0; i < num_bufs; i++)
@@ -991,25 +1136,28 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 					RTE_LOG(ERR, USER1,
 						"Compression private xform "
 						"could not be created\n");
+					ret_status = -1;
 					goto exit;
 				}
 				num_priv_xforms++;
 			}
-
 			/* Attach non shareable private xform data to ops */
 			for (i = 0; i < num_bufs; i++)
 				ops[i]->private_xform = priv_xforms[i];
 		}
+
 recovery_lb:
-		ret = test_run_enqueue_dequeue(ops, num_bufs, ops_processed);
+		ret = test_run_enqueue_dequeue(ops, ops_processed, num_bufs);
 		if (ret < 0) {
 			RTE_LOG(ERR, USER1,
-				"Enqueue/dequeue operation failed\n");
+				"Compression: enqueue/dequeue operation failed\n");
+			ret_status = -1;
 			goto exit;
 		}
 
 		for (i = 0; i < num_bufs; i++) {
-			compressed_data_size[i] += ops_processed[i]->produced;
+			priv_arrays->compressed_data_size[i] +=
+					ops_processed[i]->produced;
 
 			if (ops_processed[i]->status ==
 				RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE) {
@@ -1030,21 +1178,83 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 				if (buf_ptr == NULL) {
 					RTE_LOG(ERR, USER1,
 						"Data recovery: append extra bytes to the current mbuf failed\n");
+					ret_status = -1;
 					goto exit;
 				}
 				goto recovery_lb;
 			}
 		}
-		deqd_retries = 0;
+	}
 
-		/* Free compress private xforms */
-		for (i = 0; i < num_priv_xforms; i++) {
+exit:
+	/* Free resources */
+	if (ret_status < 0)
+		for (i = 0; i < num_bufs; i++) {
+			rte_comp_op_free(ops[i]);
+			ops_processed[i] = NULL;
+		}
+
+	/* Free compress private xforms */
+	for (i = 0; i < num_priv_xforms; i++) {
+		if (priv_xforms[i] != NULL) {
 			rte_compressdev_private_xform_free(0, priv_xforms[i]);
 			priv_xforms[i] = NULL;
 		}
-		num_priv_xforms = 0;
 	}
 
+
+
+	return ret_status;
+}
+
+/**
+ * Prints out the test report. Memory freeing.
+ *
+ * Called after successful compression.
+ * Operation(s) status validation and decompression buffers freeing.
+
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_comp_finalize(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
+{
+	/* local variables: */
+	unsigned int i;
+	struct priv_op_data *priv_data;
+
+	/* from int_data: */
+	unsigned int num_xforms = int_data->num_xforms;
+	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
+	uint16_t *buf_idx = int_data->buf_idx;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from priv_arrays: */
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
+	uint64_t *compress_checksum = priv_arrays->compress_checksum;
+	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
+	struct rte_comp_op **ops = priv_arrays->ops;
+
+	/* from test_data: */
+	unsigned int out_of_space = test_data->out_of_space;
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
+
 	for (i = 0; i < num_bufs; i++) {
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		uint16_t xform_idx = priv_data->orig_idx % num_xforms;
@@ -1053,7 +1263,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		enum rte_comp_huffman huffman_type =
 			compress_xform->deflate.huffman;
 		char engine[] = "zlib (directly, not PMD)";
-		if (zlib_dir != ZLIB_COMPRESS && zlib_dir != ZLIB_ALL)
+		if (zlib_decompress)
 			strlcpy(engine, "PMD", sizeof(engine));
 
 		RTE_LOG(DEBUG, USER1, "Buffer %u compressed by %s from %u to"
@@ -1076,15 +1286,13 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	 * compress operation information is needed for the decompression stage)
 	 */
 	for (i = 0; i < num_bufs; i++) {
-		if (out_of_space && oos_zlib_decompress) {
+		if (out_of_space && !zlib_compress) {
 			if (ops_processed[i]->status !=
 				RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
-				ret_status = -1;
-
 				RTE_LOG(ERR, USER1,
 					"Operation without expected out of "
 					"space status error\n");
-				goto exit;
+				return -1;
 			} else
 				continue;
 		}
@@ -1092,73 +1300,78 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) {
 			RTE_LOG(ERR, USER1,
 				"Some operations were not successful\n");
-			goto exit;
+			return -1;
 		}
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		rte_pktmbuf_free(uncomp_bufs[priv_data->orig_idx]);
 		uncomp_bufs[priv_data->orig_idx] = NULL;
 	}
 
-	if (out_of_space && oos_zlib_decompress) {
-		ret_status = 0;
-		goto exit;
-	}
+	if (out_of_space && !zlib_compress)
+		return 1;
 
-	/* Allocate buffers for decompressed data */
-	ret = rte_pktmbuf_alloc_bulk(buf_pool, uncomp_bufs, num_bufs);
-	if (ret < 0) {
-		RTE_LOG(ERR, USER1,
-			"Destination mbufs could not be allocated "
-			"from the mempool\n");
-		goto exit;
-	}
+	return 0;
+}
 
-	if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
-		for (i = 0; i < num_bufs; i++) {
-			priv_data = (struct priv_op_data *)
-					(ops_processed[i] + 1);
-			if (out_of_space == 1 && oos_zlib_compress)
-				data_size = OUT_OF_SPACE_BUF;
-			else
-				data_size =
-				strlen(test_bufs[priv_data->orig_idx]) + 1;
-
-			if (prepare_sgl_bufs(NULL, uncomp_bufs[i],
-			       data_size,
-			       big_data ? buf_pool : ts_params->small_mbuf_pool,
-			       big_data ? buf_pool : ts_params->large_mbuf_pool,
-			       big_data ? 0 : MAX_SEGS,
-			       big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE)
-					< 0)
-				goto exit;
-		}
+/**
+ * The main decompression function.
+ *
+ * Operation(s) configuration, depending on CLI parameters.
+ * Operation(s) processing.
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_decomp_run(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
+{
 
-	} else {
-		for (i = 0; i < num_bufs; i++) {
-			priv_data = (struct priv_op_data *)
-					(ops_processed[i] + 1);
-			if (out_of_space == 1 && oos_zlib_compress)
-				data_size = OUT_OF_SPACE_BUF;
-			else
-				data_size =
-				strlen(test_bufs[priv_data->orig_idx]) + 1;
+	/* local variables: */
+	struct priv_op_data *priv_data;
+	unsigned int i;
+	uint16_t num_priv_xforms = 0;
+	int ret;
+	int ret_status = 0;
 
-			buf_ptr = rte_pktmbuf_append(uncomp_bufs[i], data_size);
-			if (buf_ptr == NULL) {
-				RTE_LOG(ERR, USER1,
-					"Append extra bytes to the decompressed mbuf failed\n");
-				goto exit;
-			}
+	struct comp_testsuite_params *ts_params = &testsuite_params;
 
-		}
-	}
+	/* from test_data: */
+	enum rte_comp_op_type operation_type = test_data->state;
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
+
+	/* from int_data: */
+	struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms;
+	unsigned int num_xforms = int_data->num_xforms;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from priv_arrays: */
+	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
+	struct rte_comp_op **ops = priv_arrays->ops;
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
+	void **priv_xforms = priv_arrays->priv_xforms;
+	uint32_t *compressed_data_size = priv_arrays->compressed_data_size;
+
+	const struct rte_compressdev_capabilities *capa =
+		rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
 
-	/* Build the decompression operations */
 	ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Decompress operations could not be allocated "
 			"from the mempool\n");
+		ret_status = -1;
 		goto exit;
 	}
 
@@ -1178,12 +1391,14 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 			ops[i]->src.length = ops_processed[i]->produced;
 
 		ops[i]->dst.offset = 0;
-		if (state == RTE_COMP_OP_STATELESS) {
+
+		if (operation_type == RTE_COMP_OP_STATELESS) {
 			ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
 		} else {
 			RTE_LOG(ERR, USER1,
 				"Stateful operations are not supported "
 				"in these tests yet\n");
+			ret_status = -1;
 			goto exit;
 		}
 		ops[i]->input_chksum = 0;
@@ -1202,7 +1417,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	rte_comp_op_bulk_free(ops_processed, num_bufs);
 
 	/* Decompress data (either with Zlib API or compressdev API */
-	if (zlib_dir == ZLIB_DECOMPRESS || zlib_dir == ZLIB_ALL) {
+	if (zlib_decompress) {
 		for (i = 0; i < num_bufs; i++) {
 			priv_data = (struct priv_op_data *)(ops[i] + 1);
 			uint16_t xform_idx = priv_data->orig_idx % num_xforms;
@@ -1210,8 +1425,10 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 				decompress_xforms[xform_idx];
 
 			ret = decompress_zlib(ops[i], decompress_xform);
-			if (ret < 0)
+			if (ret < 0) {
+				ret_status = -1;
 				goto exit;
+			}
 
 			ops_processed[i] = ops[i];
 		}
@@ -1225,6 +1442,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 				RTE_LOG(ERR, USER1,
 					"Decompression private xform "
 					"could not be created\n");
+				ret_status = -1;
 				goto exit;
 			}
 			num_priv_xforms++;
@@ -1249,6 +1467,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 					RTE_LOG(ERR, USER1,
 						"Decompression private xform "
 						"could not be created\n");
+					ret_status = -1;
 					goto exit;
 				}
 				num_priv_xforms++;
@@ -1262,47 +1481,83 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 			}
 		}
 
-		/* Enqueue and dequeue all operations */
-		num_enqd = rte_compressdev_enqueue_burst(0, 0, ops, num_bufs);
-		if (num_enqd < num_bufs) {
+		ret = test_run_enqueue_dequeue(ops, ops_processed, num_bufs);
+		if (ret < 0) {
+			ret_status = -1;
 			RTE_LOG(ERR, USER1,
-				"The operations could not be enqueued\n");
-			goto exit;
+				"Decompression: enqueue/dequeue operation failed\n");
 		}
+	}
 
-		num_total_deqd = 0;
-		do {
-			/*
-			 * If retrying a dequeue call, wait for 10 ms to allow
-			 * enough time to the driver to process the operations
-			 */
-			if (deqd_retries != 0) {
-				/*
-				 * Avoid infinite loop if not all the
-				 * operations get out of the device
-				 */
-				if (deqd_retries == MAX_DEQD_RETRIES) {
-					RTE_LOG(ERR, USER1,
-						"Not all operations could be "
-						"dequeued\n");
-					goto exit;
-				}
-				usleep(DEQUEUE_WAIT_TIME);
-			}
-			num_deqd = rte_compressdev_dequeue_burst(0, 0,
-				&ops_processed[num_total_deqd], num_bufs);
-			num_total_deqd += num_deqd;
-			deqd_retries++;
-
-		} while (num_total_deqd < num_enqd);
+exit:
+	/* Free resources */
+	if (ret_status < 0) {
+		rte_comp_op_bulk_free(ops_processed, num_bufs);
+		rte_comp_op_bulk_free(ops, num_bufs);
+	}
 
-		deqd_retries = 0;
+	/* Free compress private xforms */
+	for (i = 0; i < num_priv_xforms; i++) {
+		if (priv_xforms[i] != NULL) {
+			rte_compressdev_private_xform_free(0, priv_xforms[i]);
+			priv_xforms[i] = NULL;
+		}
 	}
 
+	return ret_status;
+}
+
+/**
+ * Prints out the test report. Memory freeing.
+ *
+ * Called after successful decompression.
+ * Operation(s) status validation and compression buffers freeing.
+
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *     1: On success (caller should stop and exit)
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_decomp_finalize(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
+{
+	/* local variables: */
+	unsigned int i;
+	struct priv_op_data *priv_data;
+
+	/* from int_data: */
+	uint16_t *buf_idx = int_data->buf_idx;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from priv_arrays: */
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
+	struct rte_mbuf **comp_bufs = priv_arrays->comp_bufs;
+	struct rte_comp_op **ops = priv_arrays->ops;
+
+	/* from test_data: */
+	unsigned int out_of_space = test_data->out_of_space;
+
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
+
 	for (i = 0; i < num_bufs; i++) {
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		char engine[] = "zlib, (directly, no PMD)";
-		if (zlib_dir != ZLIB_DECOMPRESS && zlib_dir != ZLIB_ALL)
+		if (zlib_compress)
 			strlcpy(engine, "pmd", sizeof(engine));
 		RTE_LOG(DEBUG, USER1,
 			"Buffer %u decompressed by %s from %u to %u bytes\n",
@@ -1316,15 +1571,14 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	 * compress operation information is still needed)
 	 */
 	for (i = 0; i < num_bufs; i++) {
-		if (out_of_space && oos_zlib_compress) {
+		if (out_of_space && !zlib_decompress) {
 			if (ops_processed[i]->status !=
 				RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
-				ret_status = -1;
 
 				RTE_LOG(ERR, USER1,
 					"Operation without expected out of "
 					"space status error\n");
-				goto exit;
+				return -1;
 			} else
 				continue;
 		}
@@ -1332,17 +1586,54 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) {
 			RTE_LOG(ERR, USER1,
 				"Some operations were not successful\n");
-			goto exit;
+			return -1;
 		}
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		rte_pktmbuf_free(comp_bufs[priv_data->orig_idx]);
 		comp_bufs[priv_data->orig_idx] = NULL;
 	}
 
-	if (out_of_space && oos_zlib_compress) {
-		ret_status = 0;
-		goto exit;
-	}
+	if (out_of_space && !zlib_decompress)
+		return 1;
+
+	return 0;
+}
+
+/**
+ * Validation of the output (compression/decompression) data.
+ *
+ * The function compares the source stream with the output stream,
+ * after decompression, to check if compression/decompression
+ * was correct.
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_results_validation(const struct interim_data_params *int_data,
+		const struct test_private_arrays *priv_arrays)
+{
+	/* local variables: */
+	unsigned int i;
+	struct priv_op_data *priv_data;
+	const char *buf1;
+	const char *buf2;
+	char *contig_buf = NULL;
+
+	/* from int_data: */
+	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
+	unsigned int num_bufs = int_data->num_bufs;
+	const char * const *test_bufs = int_data->test_bufs;
+
+	/* from priv_arrays: */
+	uint64_t *compress_checksum = priv_arrays->compress_checksum;
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
 
 	/*
 	 * Compare the original stream with the decompressed stream
@@ -1350,8 +1641,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	 */
 	for (i = 0; i < num_bufs; i++) {
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
-		const char *buf1 = test_bufs[priv_data->orig_idx];
-		const char *buf2;
+		buf1 = test_bufs[priv_data->orig_idx];
 		contig_buf = rte_malloc(NULL, ops_processed[i]->produced, 0);
 		if (contig_buf == NULL) {
 			RTE_LOG(ERR, USER1, "Contiguous buffer could not "
@@ -1381,9 +1671,150 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		rte_free(contig_buf);
 		contig_buf = NULL;
 	}
+	return 0;
 
-	ret_status = 0;
+exit:
+	rte_free(contig_buf);
+	return -1;
+}
+
+/**
+ * Compresses and decompresses input stream with compressdev API and Zlib API
+ *
+ * Basic test function. Common for all the functional tests.
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_comp_decomp(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data)
+{
+	unsigned int num_bufs = int_data->num_bufs;
+	unsigned int out_of_space = test_data->out_of_space;
+
+	int ret_status = -1;
+	int ret;
+	struct rte_mbuf *uncomp_bufs[num_bufs];
+	struct rte_mbuf *comp_bufs[num_bufs];
+	struct rte_comp_op *ops[num_bufs];
+	struct rte_comp_op *ops_processed[num_bufs];
+	void *priv_xforms[num_bufs];
+	unsigned int i;
+
+	uint64_t compress_checksum[num_bufs];
+	uint32_t compressed_data_size[num_bufs];
+	char *contig_buf = NULL;
+
+	const struct rte_compressdev_capabilities *capa;
+
+	/* Compressing with CompressDev */
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
+
+	struct test_private_arrays priv_arrays;
+
+	priv_arrays.uncomp_bufs = uncomp_bufs;
+	priv_arrays.comp_bufs = comp_bufs;
+	priv_arrays.ops = ops;
+	priv_arrays.ops_processed = ops_processed;
+	priv_arrays.priv_xforms = priv_xforms;
+	priv_arrays.compress_checksum = compress_checksum;
+	priv_arrays.compressed_data_size = compressed_data_size;
+
+	capa = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
+	if (capa == NULL) {
+		RTE_LOG(ERR, USER1,
+			"Compress device does not support DEFLATE\n");
+		return -1;
+	}
+	test_objects_init(&priv_arrays, num_bufs);
+
+	/* Prepare the source mbufs with the data */
+	ret = test_mbufs_source_preparation(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+/* COMPRESSION  */
+
+	/* Prepare the destination mbufs */
+	ret = test_mbufs_destination_preparation(
+			NULL, /*can be equal to NULL*/
+			comp_bufs,
+			out_of_space == 1 && !zlib_compress,
+			int_data,
+			test_data);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	/* Run compression */
+	ret = test_deflate_comp_run(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	ret = test_deflate_comp_finalize(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	} else if (ret == 1) {
+		ret_status = 0;
+		goto exit;
+	}
+
+/* DECOMPRESSION  */
 
+	/* Allocate buffers for decompressed data */
+	ret = test_mbufs_destination_preparation(
+			ops_processed, /*can be equal to NULL*/
+			uncomp_bufs,
+			out_of_space == 1 && !zlib_decompress,
+			int_data,
+			test_data);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	/* Run decompression */
+	ret = test_deflate_decomp_run(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	ret = test_deflate_decomp_finalize(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	} else if (ret == 1) {
+		ret_status = 0;
+		goto exit;
+	}
+
+/* FINAL PROCESSING  */
+
+	ret = test_results_validation(int_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+	ret_status = 0;
 exit:
 	/* Free resources */
 	for (i = 0; i < num_bufs; i++) {
@@ -1392,10 +1823,6 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		rte_comp_op_free(ops[i]);
 		rte_comp_op_free(ops_processed[i]);
 	}
-	for (i = 0; i < num_priv_xforms; i++) {
-		if (priv_xforms[i] != NULL)
-			rte_compressdev_private_xform_free(0, priv_xforms[i]);
-	}
 	rte_free(contig_buf);
 
 	return ret_status;
-- 
2.17.1

[dpdk-dev] [PATCH v2 0/1] compression: unit tests refactoring

[Artur Trybula]

v2 changes:
	- unnecessary "printf" removed from the code

This patch depends on "test/compress: unit test for stateless
overflow recovery": http://patches.dpdk.org/patch/58834/

Signed-off-by: Artur Trybula <arturx.trybula@intel.com>

Artur Trybula (1):
  test/compress: unit tests refactoring

 app/test/test_compressdev.c | 832 +++++++++++++++++++++++++++---------
 1 file changed, 629 insertions(+), 203 deletions(-)

-- 
2.17.1

[dpdk-dev] [PATCH v2 1/1] test/compress: unit tests refactoring

[Artur Trybula]

Core engine refactoring (test_deflate_comp_decomp function).
Smaller specialized functions created.

Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
---
This patch depends on "test/compress: unit test for stateless
overflow recovery": http://patches.dpdk.org/patch/58834/

 app/test/test_compressdev.c | 832 +++++++++++++++++++++++++++---------
 1 file changed, 629 insertions(+), 203 deletions(-)

diff --git a/app/test/test_compressdev.c b/app/test/test_compressdev.c
index 3a655164f..c433e5efb 100644
--- a/app/test/test_compressdev.c
+++ b/app/test/test_compressdev.c
@@ -110,6 +110,16 @@ struct test_data_params {
 	enum overflow_test overflow;
 };
 
+struct test_private_arrays {
+	struct rte_mbuf **uncomp_bufs;
+	struct rte_mbuf **comp_bufs;
+	struct rte_comp_op **ops;
+	struct rte_comp_op **ops_processed;
+	void **priv_xforms;
+	uint64_t *compress_checksum;
+	uint32_t *compressed_data_size;
+};
+
 static struct comp_testsuite_params testsuite_params = { 0 };
 
 static void
@@ -721,8 +731,9 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf,
 
 
 static int
-test_run_enqueue_dequeue(struct rte_comp_op **ops, unsigned int num_bufs,
-		  struct rte_comp_op **ops_processed)
+test_run_enqueue_dequeue(struct rte_comp_op **ops,
+			 struct rte_comp_op **ops_processed,
+			 unsigned int num_bufs)
 {
 	uint16_t num_enqd, num_deqd, num_total_deqd;
 	unsigned int deqd_retries = 0;
@@ -763,66 +774,70 @@ test_run_enqueue_dequeue(struct rte_comp_op **ops, unsigned int num_bufs,
 	return 0;
 }
 
-/*
- * Compresses and decompresses buffer with compressdev API and Zlib API
+/**
+ * Initialize all the arrays used in comp/decomp to NULL.
+ *
+ * If the length is greater than the length of the last segment, the
+ * function will fail and return -1 without modifying the mbuf.
+ *
+ * @param priv_arrays
+ *   A container used for aggregation all the arrays.
+ * @param num_bufs
+ *   The number of elements in each array.
+ */
+static void
+test_objects_init(struct test_private_arrays *prv,
+		unsigned int num_bufs)
+{
+	/* Initialize all arrays to NULL */
+	memset(prv->uncomp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
+	memset(prv->comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
+	memset(prv->ops, 0, sizeof(struct rte_comp_op *) * num_bufs);
+	memset(prv->ops_processed, 0, sizeof(struct rte_comp_op *) * num_bufs);
+	memset(prv->priv_xforms, 0, sizeof(void *) * num_bufs);
+	memset(prv->compressed_data_size, 0, sizeof(uint32_t) * num_bufs);
+}
+
+/**
+ * Source buffers preparation (for compression).
+ *
+ * Memory allocation for each buffer from mempool
+ * -1 returned if function fail, without modifying the mbuf.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
  */
 static int
-test_deflate_comp_decomp(const struct interim_data_params *int_data,
-		const struct test_data_params *test_data)
+test_mbufs_source_preparation(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
 {
+	/* local variables: */
+	unsigned int i;
+	uint32_t data_size;
+	char *buf_ptr;
+	int ret;
+
 	struct comp_testsuite_params *ts_params = &testsuite_params;
+
+	/* from int_data: */
 	const char * const *test_bufs = int_data->test_bufs;
 	unsigned int num_bufs = int_data->num_bufs;
-	uint16_t *buf_idx = int_data->buf_idx;
-	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
-	struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms;
-	unsigned int num_xforms = int_data->num_xforms;
-	enum rte_comp_op_type state = test_data->state;
+
+	/* from test_data: */
 	unsigned int buff_type = test_data->buff_type;
-	unsigned int out_of_space = test_data->out_of_space;
 	unsigned int big_data = test_data->big_data;
-	enum zlib_direction zlib_dir = test_data->zlib_dir;
-	enum overflow_test overflow_tst = test_data->overflow;
-	int ret_status = -1;
-	int ret;
-	struct rte_mbuf *uncomp_bufs[num_bufs];
-	struct rte_mbuf *comp_bufs[num_bufs];
-	struct rte_comp_op *ops[num_bufs];
-	struct rte_comp_op *ops_processed[num_bufs];
-	void *priv_xforms[num_bufs];
-	uint16_t num_enqd, num_deqd, num_total_deqd;
-	uint16_t num_priv_xforms = 0;
-	unsigned int deqd_retries = 0;
-	struct priv_op_data *priv_data;
-	char *buf_ptr;
-	unsigned int i;
-	struct rte_mempool *buf_pool;
-	uint32_t data_size;
-	/* Compressing with CompressDev */
-	unsigned int oos_zlib_decompress =
-			(zlib_dir == ZLIB_NONE || zlib_dir == ZLIB_DECOMPRESS);
-	/* Decompressing with CompressDev */
-	unsigned int oos_zlib_compress =
-			(zlib_dir == ZLIB_NONE || zlib_dir == ZLIB_COMPRESS);
-	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];
-	uint32_t compressed_data_size[num_bufs];
 
-	if (capa == NULL) {
-		RTE_LOG(ERR, USER1,
-			"Compress device does not support DEFLATE\n");
-		return -1;
-	}
-
-	/* Initialize all arrays to NULL */
-	memset(uncomp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
-	memset(comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
-	memset(ops, 0, sizeof(struct rte_comp_op *) * num_bufs);
-	memset(ops_processed, 0, sizeof(struct rte_comp_op *) * num_bufs);
-	memset(priv_xforms, 0, sizeof(void *) * num_bufs);
-	memset(compressed_data_size, 0, sizeof(uint32_t) * num_bufs);
+	/* from priv_arrays: */
+	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
+	struct rte_mempool *buf_pool;
 
 	if (big_data)
 		buf_pool = ts_params->big_mbuf_pool;
@@ -831,14 +846,15 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	else
 		buf_pool = ts_params->large_mbuf_pool;
 
-	/* Prepare the source mbufs with the data */
+	/* for compression uncomp_bufs is used as a source buffer */
+	/* allocation from buf_pool (mempool type) */
 	ret = rte_pktmbuf_alloc_bulk(buf_pool,
 				uncomp_bufs, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Source mbufs could not be allocated "
 			"from the mempool\n");
-		goto exit;
+		return -1;
 	}
 
 	if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
@@ -850,7 +866,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 			    big_data ? buf_pool : ts_params->large_mbuf_pool,
 			    big_data ? 0 : MAX_SEGS,
 			    big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) < 0)
-				goto exit;
+				return -1;
 		}
 	} else {
 		for (i = 0; i < num_bufs; i++) {
@@ -860,68 +876,193 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 			if (buf_ptr == NULL) {
 				RTE_LOG(ERR, USER1,
 					"Append extra bytes to the source mbuf failed\n");
-				goto exit;
+				return -1;
 			}
 			strlcpy(buf_ptr, test_bufs[i], data_size);
 		}
 	}
 
-	/* Prepare the destination mbufs */
-	ret = rte_pktmbuf_alloc_bulk(buf_pool, comp_bufs, num_bufs);
+	return 0;
+}
+
+/**
+ * Memory buffers preparation (for both compression and decompression).
+ *
+ * Memory allocation for comp/decomp buffers from mempool, depending on
+ * ops_processed value. Developer is requested to provide input params
+ * according to the following rule:
+ *      if ops_processed == NULL -> current_bufs = comp_bufs[]
+ *      if ops_processed != NULL -> current_bufs = decomp_bufs[]
+ * -1 returned if function fail, without modifying the mbuf.
+ *
+ * @param ops_processed
+ *   Operations created as a result of compression phase. Should be
+ *   set to NULL for compression
+ * @param current_bufs
+ *   mbufs being prepared in the function.
+ * @param out_of_space_and_zlib
+ *   Boolean value to switch into "out of space" buffer if set.
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_mbufs_destination_preparation(
+		struct rte_comp_op *ops_processed[], /*can be equal to NULL*/
+		struct rte_mbuf *current_bufs[],
+		unsigned int out_of_space_and_zlib,
+		const struct interim_data_params *int_data,
+		const struct test_data_params *test_data)
+{
+	/* local variables: */
+	unsigned int i;
+	uint32_t data_size;
+	struct priv_op_data *priv_data;
+	int ret;
+	char *buf_ptr;
+
+	struct comp_testsuite_params *ts_params = &testsuite_params;
+
+	/* from int_data: */
+	const char * const *test_bufs = int_data->test_bufs;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from test_data: */
+	unsigned int buff_type = test_data->buff_type;
+	unsigned int big_data = test_data->big_data;
+
+	/* from priv_arrays: */
+	struct rte_mempool *buf_pool;
+
+	if (big_data)
+		buf_pool = ts_params->big_mbuf_pool;
+	else if (buff_type == SGL_BOTH)
+		buf_pool = ts_params->small_mbuf_pool;
+	else
+		buf_pool = ts_params->large_mbuf_pool;
+
+	/* the mbufs allocation*/
+	ret = rte_pktmbuf_alloc_bulk(buf_pool, current_bufs, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Destination mbufs could not be allocated "
 			"from the mempool\n");
-		goto exit;
+		return -1;
 	}
 
-	if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
-		for (i = 0; i < num_bufs; i++) {
-			if (out_of_space == 1 && oos_zlib_decompress)
-				data_size = OUT_OF_SPACE_BUF;
-			else
-				(data_size = strlen(test_bufs[i]) *
-					COMPRESS_BUF_SIZE_RATIO);
-
-			if (prepare_sgl_bufs(NULL, comp_bufs[i],
-			      data_size,
-			      big_data ? buf_pool : ts_params->small_mbuf_pool,
-			      big_data ? buf_pool : ts_params->large_mbuf_pool,
-			      big_data ? 0 : MAX_SEGS,
-			      big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE)
-					< 0)
-				goto exit;
-		}
+	for (i = 0; i < num_bufs; i++) {
 
-	} else {
-		for (i = 0; i < num_bufs; i++) {
-			if (out_of_space == 1 && oos_zlib_decompress)
-				data_size = OUT_OF_SPACE_BUF;
-			else {
+		/* data size calculation */
+		if (out_of_space_and_zlib)
+			data_size = OUT_OF_SPACE_BUF;
+		else {
+			if (ops_processed == NULL) {
 				float ratio =
 				((test_data->zlib_dir == ZLIB_DECOMPRESS ||
-				   test_data->zlib_dir == ZLIB_NONE) &&
-				  overflow_tst == OVERFLOW_ENABLED) ?
+				  test_data->zlib_dir == ZLIB_NONE) &&
+				  test_data->overflow == OVERFLOW_ENABLED) ?
 					 COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
 					 COMPRESS_BUF_SIZE_RATIO;
 
 				data_size = strlen(test_bufs[i]) * ratio;
+
+			} else {
+				priv_data = (struct priv_op_data *)
+					(ops_processed[i] + 1);
+				data_size =
+					strlen(test_bufs[priv_data->orig_idx])
+					+ 1;
 			}
-			buf_ptr = rte_pktmbuf_append(comp_bufs[i], data_size);
+		}
+
+		/* data allocation */
+		if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
+			ret = prepare_sgl_bufs(NULL, current_bufs[i],
+			      data_size,
+			      big_data ? buf_pool : ts_params->small_mbuf_pool,
+			      big_data ? buf_pool : ts_params->large_mbuf_pool,
+			      big_data ? 0 : MAX_SEGS,
+			      big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE);
+			if (ret < 0)
+				return -1;
+		} else {
+			buf_ptr = rte_pktmbuf_append(current_bufs[i],
+					data_size);
 			if (buf_ptr == NULL) {
 				RTE_LOG(ERR, USER1,
 					"Append extra bytes to the destination mbuf failed\n");
-				goto exit;
+				return -1;
 			}
 		}
 	}
 
+	return 0;
+}
+
+/**
+ * The main compression function.
+ *
+ * Operation(s) configuration, depending on CLI parameters.
+ * Operation(s) processing.
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_comp_run(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
+{
+	/* local variables: */
+	struct priv_op_data *priv_data;
+	unsigned int i;
+	uint16_t num_priv_xforms = 0;
+	int ret;
+	int ret_status = 0;
+	char *buf_ptr;
+
+	struct comp_testsuite_params *ts_params = &testsuite_params;
+
+	/* from test_data: */
+	enum rte_comp_op_type operation_type = test_data->state;
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+
+	/* from int_data: */
+	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
+	unsigned int num_xforms = int_data->num_xforms;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from priv_arrays: */
+	struct rte_mbuf **comp_bufs = priv_arrays->comp_bufs;
+	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
+	struct rte_comp_op **ops = priv_arrays->ops;
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
+	void **priv_xforms = priv_arrays->priv_xforms;
+
+	const struct rte_compressdev_capabilities *capa =
+		rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
+
 	/* Build the compression operations */
 	ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Compress operations could not be allocated "
 			"from the mempool\n");
+		ret_status = -1;
 		goto exit;
 	}
 
@@ -931,12 +1072,13 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		ops[i]->src.offset = 0;
 		ops[i]->src.length = rte_pktmbuf_pkt_len(uncomp_bufs[i]);
 		ops[i]->dst.offset = 0;
-		if (state == RTE_COMP_OP_STATELESS) {
+		if (operation_type == RTE_COMP_OP_STATELESS) {
 			ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
 		} else {
 			RTE_LOG(ERR, USER1,
 				"Stateful operations are not supported "
 				"in these tests yet\n");
+			ret_status = -1;
 			goto exit;
 		}
 		ops[i]->input_chksum = 0;
@@ -951,14 +1093,16 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	}
 
 	/* Compress data (either with Zlib API or compressdev API */
-	if (zlib_dir == ZLIB_COMPRESS || zlib_dir == ZLIB_ALL) {
+	if (zlib_compress) {
 		for (i = 0; i < num_bufs; i++) {
 			const struct rte_comp_xform *compress_xform =
 				compress_xforms[i % num_xforms];
 			ret = compress_zlib(ops[i], compress_xform,
 					DEFAULT_MEM_LEVEL);
-			if (ret < 0)
+			if (ret < 0) {
+				ret_status = -1;
 				goto exit;
+			}
 
 			ops_processed[i] = ops[i];
 		}
@@ -972,11 +1116,11 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 				RTE_LOG(ERR, USER1,
 					"Compression private xform "
 					"could not be created\n");
+				ret_status = -1;
 				goto exit;
 			}
 			num_priv_xforms++;
 		}
-
 		if (capa->comp_feature_flags & RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
 			/* Attach shareable private xform data to ops */
 			for (i = 0; i < num_bufs; i++)
@@ -991,25 +1135,28 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 					RTE_LOG(ERR, USER1,
 						"Compression private xform "
 						"could not be created\n");
+					ret_status = -1;
 					goto exit;
 				}
 				num_priv_xforms++;
 			}
-
 			/* Attach non shareable private xform data to ops */
 			for (i = 0; i < num_bufs; i++)
 				ops[i]->private_xform = priv_xforms[i];
 		}
+
 recovery_lb:
-		ret = test_run_enqueue_dequeue(ops, num_bufs, ops_processed);
+		ret = test_run_enqueue_dequeue(ops, ops_processed, num_bufs);
 		if (ret < 0) {
 			RTE_LOG(ERR, USER1,
-				"Enqueue/dequeue operation failed\n");
+				"Compression: enqueue/dequeue operation failed\n");
+			ret_status = -1;
 			goto exit;
 		}
 
 		for (i = 0; i < num_bufs; i++) {
-			compressed_data_size[i] += ops_processed[i]->produced;
+			priv_arrays->compressed_data_size[i] +=
+					ops_processed[i]->produced;
 
 			if (ops_processed[i]->status ==
 				RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE) {
@@ -1030,21 +1177,83 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 				if (buf_ptr == NULL) {
 					RTE_LOG(ERR, USER1,
 						"Data recovery: append extra bytes to the current mbuf failed\n");
+					ret_status = -1;
 					goto exit;
 				}
 				goto recovery_lb;
 			}
 		}
-		deqd_retries = 0;
+	}
 
-		/* Free compress private xforms */
-		for (i = 0; i < num_priv_xforms; i++) {
+exit:
+	/* Free resources */
+	if (ret_status < 0)
+		for (i = 0; i < num_bufs; i++) {
+			rte_comp_op_free(ops[i]);
+			ops_processed[i] = NULL;
+		}
+
+	/* Free compress private xforms */
+	for (i = 0; i < num_priv_xforms; i++) {
+		if (priv_xforms[i] != NULL) {
 			rte_compressdev_private_xform_free(0, priv_xforms[i]);
 			priv_xforms[i] = NULL;
 		}
-		num_priv_xforms = 0;
 	}
 
+
+
+	return ret_status;
+}
+
+/**
+ * Prints out the test report. Memory freeing.
+ *
+ * Called after successful compression.
+ * Operation(s) status validation and decompression buffers freeing.
+
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_comp_finalize(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
+{
+	/* local variables: */
+	unsigned int i;
+	struct priv_op_data *priv_data;
+
+	/* from int_data: */
+	unsigned int num_xforms = int_data->num_xforms;
+	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
+	uint16_t *buf_idx = int_data->buf_idx;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from priv_arrays: */
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
+	uint64_t *compress_checksum = priv_arrays->compress_checksum;
+	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
+	struct rte_comp_op **ops = priv_arrays->ops;
+
+	/* from test_data: */
+	unsigned int out_of_space = test_data->out_of_space;
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
+
 	for (i = 0; i < num_bufs; i++) {
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		uint16_t xform_idx = priv_data->orig_idx % num_xforms;
@@ -1053,7 +1262,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		enum rte_comp_huffman huffman_type =
 			compress_xform->deflate.huffman;
 		char engine[] = "zlib (directly, not PMD)";
-		if (zlib_dir != ZLIB_COMPRESS && zlib_dir != ZLIB_ALL)
+		if (zlib_decompress)
 			strlcpy(engine, "PMD", sizeof(engine));
 
 		RTE_LOG(DEBUG, USER1, "Buffer %u compressed by %s from %u to"
@@ -1076,15 +1285,13 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	 * compress operation information is needed for the decompression stage)
 	 */
 	for (i = 0; i < num_bufs; i++) {
-		if (out_of_space && oos_zlib_decompress) {
+		if (out_of_space && !zlib_compress) {
 			if (ops_processed[i]->status !=
 				RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
-				ret_status = -1;
-
 				RTE_LOG(ERR, USER1,
 					"Operation without expected out of "
 					"space status error\n");
-				goto exit;
+				return -1;
 			} else
 				continue;
 		}
@@ -1092,73 +1299,78 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) {
 			RTE_LOG(ERR, USER1,
 				"Some operations were not successful\n");
-			goto exit;
+			return -1;
 		}
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		rte_pktmbuf_free(uncomp_bufs[priv_data->orig_idx]);
 		uncomp_bufs[priv_data->orig_idx] = NULL;
 	}
 
-	if (out_of_space && oos_zlib_decompress) {
-		ret_status = 0;
-		goto exit;
-	}
+	if (out_of_space && !zlib_compress)
+		return 1;
 
-	/* Allocate buffers for decompressed data */
-	ret = rte_pktmbuf_alloc_bulk(buf_pool, uncomp_bufs, num_bufs);
-	if (ret < 0) {
-		RTE_LOG(ERR, USER1,
-			"Destination mbufs could not be allocated "
-			"from the mempool\n");
-		goto exit;
-	}
+	return 0;
+}
 
-	if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
-		for (i = 0; i < num_bufs; i++) {
-			priv_data = (struct priv_op_data *)
-					(ops_processed[i] + 1);
-			if (out_of_space == 1 && oos_zlib_compress)
-				data_size = OUT_OF_SPACE_BUF;
-			else
-				data_size =
-				strlen(test_bufs[priv_data->orig_idx]) + 1;
-
-			if (prepare_sgl_bufs(NULL, uncomp_bufs[i],
-			       data_size,
-			       big_data ? buf_pool : ts_params->small_mbuf_pool,
-			       big_data ? buf_pool : ts_params->large_mbuf_pool,
-			       big_data ? 0 : MAX_SEGS,
-			       big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE)
-					< 0)
-				goto exit;
-		}
+/**
+ * The main decompression function.
+ *
+ * Operation(s) configuration, depending on CLI parameters.
+ * Operation(s) processing.
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_decomp_run(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
+{
 
-	} else {
-		for (i = 0; i < num_bufs; i++) {
-			priv_data = (struct priv_op_data *)
-					(ops_processed[i] + 1);
-			if (out_of_space == 1 && oos_zlib_compress)
-				data_size = OUT_OF_SPACE_BUF;
-			else
-				data_size =
-				strlen(test_bufs[priv_data->orig_idx]) + 1;
+	/* local variables: */
+	struct priv_op_data *priv_data;
+	unsigned int i;
+	uint16_t num_priv_xforms = 0;
+	int ret;
+	int ret_status = 0;
 
-			buf_ptr = rte_pktmbuf_append(uncomp_bufs[i], data_size);
-			if (buf_ptr == NULL) {
-				RTE_LOG(ERR, USER1,
-					"Append extra bytes to the decompressed mbuf failed\n");
-				goto exit;
-			}
+	struct comp_testsuite_params *ts_params = &testsuite_params;
 
-		}
-	}
+	/* from test_data: */
+	enum rte_comp_op_type operation_type = test_data->state;
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
+
+	/* from int_data: */
+	struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms;
+	unsigned int num_xforms = int_data->num_xforms;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from priv_arrays: */
+	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
+	struct rte_comp_op **ops = priv_arrays->ops;
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
+	void **priv_xforms = priv_arrays->priv_xforms;
+	uint32_t *compressed_data_size = priv_arrays->compressed_data_size;
+
+	const struct rte_compressdev_capabilities *capa =
+		rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
 
-	/* Build the decompression operations */
 	ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Decompress operations could not be allocated "
 			"from the mempool\n");
+		ret_status = -1;
 		goto exit;
 	}
 
@@ -1178,12 +1390,14 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 			ops[i]->src.length = ops_processed[i]->produced;
 
 		ops[i]->dst.offset = 0;
-		if (state == RTE_COMP_OP_STATELESS) {
+
+		if (operation_type == RTE_COMP_OP_STATELESS) {
 			ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
 		} else {
 			RTE_LOG(ERR, USER1,
 				"Stateful operations are not supported "
 				"in these tests yet\n");
+			ret_status = -1;
 			goto exit;
 		}
 		ops[i]->input_chksum = 0;
@@ -1202,7 +1416,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	rte_comp_op_bulk_free(ops_processed, num_bufs);
 
 	/* Decompress data (either with Zlib API or compressdev API */
-	if (zlib_dir == ZLIB_DECOMPRESS || zlib_dir == ZLIB_ALL) {
+	if (zlib_decompress) {
 		for (i = 0; i < num_bufs; i++) {
 			priv_data = (struct priv_op_data *)(ops[i] + 1);
 			uint16_t xform_idx = priv_data->orig_idx % num_xforms;
@@ -1210,8 +1424,10 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 				decompress_xforms[xform_idx];
 
 			ret = decompress_zlib(ops[i], decompress_xform);
-			if (ret < 0)
+			if (ret < 0) {
+				ret_status = -1;
 				goto exit;
+			}
 
 			ops_processed[i] = ops[i];
 		}
@@ -1225,6 +1441,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 				RTE_LOG(ERR, USER1,
 					"Decompression private xform "
 					"could not be created\n");
+				ret_status = -1;
 				goto exit;
 			}
 			num_priv_xforms++;
@@ -1249,6 +1466,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 					RTE_LOG(ERR, USER1,
 						"Decompression private xform "
 						"could not be created\n");
+					ret_status = -1;
 					goto exit;
 				}
 				num_priv_xforms++;
@@ -1262,47 +1480,83 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 			}
 		}
 
-		/* Enqueue and dequeue all operations */
-		num_enqd = rte_compressdev_enqueue_burst(0, 0, ops, num_bufs);
-		if (num_enqd < num_bufs) {
+		ret = test_run_enqueue_dequeue(ops, ops_processed, num_bufs);
+		if (ret < 0) {
+			ret_status = -1;
 			RTE_LOG(ERR, USER1,
-				"The operations could not be enqueued\n");
-			goto exit;
+				"Decompression: enqueue/dequeue operation failed\n");
 		}
+	}
 
-		num_total_deqd = 0;
-		do {
-			/*
-			 * If retrying a dequeue call, wait for 10 ms to allow
-			 * enough time to the driver to process the operations
-			 */
-			if (deqd_retries != 0) {
-				/*
-				 * Avoid infinite loop if not all the
-				 * operations get out of the device
-				 */
-				if (deqd_retries == MAX_DEQD_RETRIES) {
-					RTE_LOG(ERR, USER1,
-						"Not all operations could be "
-						"dequeued\n");
-					goto exit;
-				}
-				usleep(DEQUEUE_WAIT_TIME);
-			}
-			num_deqd = rte_compressdev_dequeue_burst(0, 0,
-				&ops_processed[num_total_deqd], num_bufs);
-			num_total_deqd += num_deqd;
-			deqd_retries++;
-
-		} while (num_total_deqd < num_enqd);
+exit:
+	/* Free resources */
+	if (ret_status < 0) {
+		rte_comp_op_bulk_free(ops_processed, num_bufs);
+		rte_comp_op_bulk_free(ops, num_bufs);
+	}
 
-		deqd_retries = 0;
+	/* Free compress private xforms */
+	for (i = 0; i < num_priv_xforms; i++) {
+		if (priv_xforms[i] != NULL) {
+			rte_compressdev_private_xform_free(0, priv_xforms[i]);
+			priv_xforms[i] = NULL;
+		}
 	}
 
+	return ret_status;
+}
+
+/**
+ * Prints out the test report. Memory freeing.
+ *
+ * Called after successful decompression.
+ * Operation(s) status validation and compression buffers freeing.
+
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *     1: On success (caller should stop and exit)
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_decomp_finalize(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
+{
+	/* local variables: */
+	unsigned int i;
+	struct priv_op_data *priv_data;
+
+	/* from int_data: */
+	uint16_t *buf_idx = int_data->buf_idx;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from priv_arrays: */
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
+	struct rte_mbuf **comp_bufs = priv_arrays->comp_bufs;
+	struct rte_comp_op **ops = priv_arrays->ops;
+
+	/* from test_data: */
+	unsigned int out_of_space = test_data->out_of_space;
+
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
+
 	for (i = 0; i < num_bufs; i++) {
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		char engine[] = "zlib, (directly, no PMD)";
-		if (zlib_dir != ZLIB_DECOMPRESS && zlib_dir != ZLIB_ALL)
+		if (zlib_compress)
 			strlcpy(engine, "pmd", sizeof(engine));
 		RTE_LOG(DEBUG, USER1,
 			"Buffer %u decompressed by %s from %u to %u bytes\n",
@@ -1316,15 +1570,14 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	 * compress operation information is still needed)
 	 */
 	for (i = 0; i < num_bufs; i++) {
-		if (out_of_space && oos_zlib_compress) {
+		if (out_of_space && !zlib_decompress) {
 			if (ops_processed[i]->status !=
 				RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
-				ret_status = -1;
 
 				RTE_LOG(ERR, USER1,
 					"Operation without expected out of "
 					"space status error\n");
-				goto exit;
+				return -1;
 			} else
 				continue;
 		}
@@ -1332,17 +1585,54 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) {
 			RTE_LOG(ERR, USER1,
 				"Some operations were not successful\n");
-			goto exit;
+			return -1;
 		}
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		rte_pktmbuf_free(comp_bufs[priv_data->orig_idx]);
 		comp_bufs[priv_data->orig_idx] = NULL;
 	}
 
-	if (out_of_space && oos_zlib_compress) {
-		ret_status = 0;
-		goto exit;
-	}
+	if (out_of_space && !zlib_decompress)
+		return 1;
+
+	return 0;
+}
+
+/**
+ * Validation of the output (compression/decompression) data.
+ *
+ * The function compares the source stream with the output stream,
+ * after decompression, to check if compression/decompression
+ * was correct.
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_results_validation(const struct interim_data_params *int_data,
+		const struct test_private_arrays *priv_arrays)
+{
+	/* local variables: */
+	unsigned int i;
+	struct priv_op_data *priv_data;
+	const char *buf1;
+	const char *buf2;
+	char *contig_buf = NULL;
+
+	/* from int_data: */
+	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
+	unsigned int num_bufs = int_data->num_bufs;
+	const char * const *test_bufs = int_data->test_bufs;
+
+	/* from priv_arrays: */
+	uint64_t *compress_checksum = priv_arrays->compress_checksum;
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
 
 	/*
 	 * Compare the original stream with the decompressed stream
@@ -1350,8 +1640,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	 */
 	for (i = 0; i < num_bufs; i++) {
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
-		const char *buf1 = test_bufs[priv_data->orig_idx];
-		const char *buf2;
+		buf1 = test_bufs[priv_data->orig_idx];
 		contig_buf = rte_malloc(NULL, ops_processed[i]->produced, 0);
 		if (contig_buf == NULL) {
 			RTE_LOG(ERR, USER1, "Contiguous buffer could not "
@@ -1381,9 +1670,150 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		rte_free(contig_buf);
 		contig_buf = NULL;
 	}
+	return 0;
 
-	ret_status = 0;
+exit:
+	rte_free(contig_buf);
+	return -1;
+}
+
+/**
+ * Compresses and decompresses input stream with compressdev API and Zlib API
+ *
+ * Basic test function. Common for all the functional tests.
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_comp_decomp(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data)
+{
+	unsigned int num_bufs = int_data->num_bufs;
+	unsigned int out_of_space = test_data->out_of_space;
+
+	int ret_status = -1;
+	int ret;
+	struct rte_mbuf *uncomp_bufs[num_bufs];
+	struct rte_mbuf *comp_bufs[num_bufs];
+	struct rte_comp_op *ops[num_bufs];
+	struct rte_comp_op *ops_processed[num_bufs];
+	void *priv_xforms[num_bufs];
+	unsigned int i;
+
+	uint64_t compress_checksum[num_bufs];
+	uint32_t compressed_data_size[num_bufs];
+	char *contig_buf = NULL;
+
+	const struct rte_compressdev_capabilities *capa;
+
+	/* Compressing with CompressDev */
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
+
+	struct test_private_arrays priv_arrays;
+
+	priv_arrays.uncomp_bufs = uncomp_bufs;
+	priv_arrays.comp_bufs = comp_bufs;
+	priv_arrays.ops = ops;
+	priv_arrays.ops_processed = ops_processed;
+	priv_arrays.priv_xforms = priv_xforms;
+	priv_arrays.compress_checksum = compress_checksum;
+	priv_arrays.compressed_data_size = compressed_data_size;
+
+	capa = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
+	if (capa == NULL) {
+		RTE_LOG(ERR, USER1,
+			"Compress device does not support DEFLATE\n");
+		return -1;
+	}
+	test_objects_init(&priv_arrays, num_bufs);
+
+	/* Prepare the source mbufs with the data */
+	ret = test_mbufs_source_preparation(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+/* COMPRESSION  */
+
+	/* Prepare the destination mbufs */
+	ret = test_mbufs_destination_preparation(
+			NULL, /*can be equal to NULL*/
+			comp_bufs,
+			out_of_space == 1 && !zlib_compress,
+			int_data,
+			test_data);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	/* Run compression */
+	ret = test_deflate_comp_run(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	ret = test_deflate_comp_finalize(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	} else if (ret == 1) {
+		ret_status = 0;
+		goto exit;
+	}
+
+/* DECOMPRESSION  */
 
+	/* Allocate buffers for decompressed data */
+	ret = test_mbufs_destination_preparation(
+			ops_processed, /*can be equal to NULL*/
+			uncomp_bufs,
+			out_of_space == 1 && !zlib_decompress,
+			int_data,
+			test_data);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	/* Run decompression */
+	ret = test_deflate_decomp_run(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	ret = test_deflate_decomp_finalize(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	} else if (ret == 1) {
+		ret_status = 0;
+		goto exit;
+	}
+
+/* FINAL PROCESSING  */
+
+	ret = test_results_validation(int_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+	ret_status = 0;
 exit:
 	/* Free resources */
 	for (i = 0; i < num_bufs; i++) {
@@ -1392,10 +1822,6 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		rte_comp_op_free(ops[i]);
 		rte_comp_op_free(ops_processed[i]);
 	}
-	for (i = 0; i < num_priv_xforms; i++) {
-		if (priv_xforms[i] != NULL)
-			rte_compressdev_private_xform_free(0, priv_xforms[i]);
-	}
 	rte_free(contig_buf);
 
 	return ret_status;
-- 
2.17.1

[dpdk-dev] [PATCH v3 0/1] compression: unit tests refactoring

[Artur Trybula]

v3 changes:
	- rebase onto the recent master
	- small modifications after code review
	- additional function extracted for data size calculation
	  (test_mbufs_calculate_data_size)

v2 changes:
	- unnecessary "printf" removed from the code

Signed-off-by: Artur Trybula <arturx.trybula@intel.com>

Artur Trybula (1):
  test/compress: unit tests refactoring

 app/test/test_compressdev.c            | 1118 +++++++++++++++++-------
 doc/guides/rel_notes/release_19_11.rst |    5 +
 2 files changed, 826 insertions(+), 297 deletions(-)

-- 
2.17.1

[dpdk-dev] [PATCH v3 1/1] test/compress: unit tests refactoring

[Artur Trybula]

Core engine refactoring (test_deflate_comp_decomp function).
Smaller specialized functions created.

Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
---
 app/test/test_compressdev.c            | 1118 +++++++++++++++++-------
 doc/guides/rel_notes/release_19_11.rst |    5 +
 2 files changed, 826 insertions(+), 297 deletions(-)

diff --git a/app/test/test_compressdev.c b/app/test/test_compressdev.c
index 283c64971..4932bec76 100644
--- a/app/test/test_compressdev.c
+++ b/app/test/test_compressdev.c
@@ -120,6 +120,20 @@ struct test_data_params {
 	enum overflow_test overflow;
 };
 
+struct test_private_arrays {
+	struct rte_mbuf **uncomp_bufs;
+	struct rte_mbuf **comp_bufs;
+	struct rte_comp_op **ops;
+	struct rte_comp_op **ops_processed;
+	void **priv_xforms;
+	uint64_t *compress_checksum;
+	uint32_t *compressed_data_size;
+	void **stream;
+	char **all_decomp_data;
+	unsigned int *decomp_produced_data_size;
+	uint16_t num_priv_xforms;
+};
+
 static struct comp_testsuite_params testsuite_params = { 0 };
 
 static void
@@ -662,6 +676,7 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf,
 		data_size = remaining_data;
 	else
 		data_size = seg_size;
+
 	buf_ptr = rte_pktmbuf_append(head_buf, data_size);
 	if (buf_ptr == NULL) {
 		RTE_LOG(ERR, USER1,
@@ -734,8 +749,9 @@ extbuf_free_callback(void *addr __rte_unused, void *opaque __rte_unused)
 }
 
 static int
-test_run_enqueue_dequeue(struct rte_comp_op **ops, unsigned int num_bufs,
-		  struct rte_comp_op **ops_processed)
+test_run_enqueue_dequeue(struct rte_comp_op **ops,
+			 struct rte_comp_op **ops_processed,
+			 unsigned int num_bufs)
 {
 	uint16_t num_enqd, num_deqd, num_total_deqd;
 	unsigned int deqd_retries = 0;
@@ -776,81 +792,77 @@ test_run_enqueue_dequeue(struct rte_comp_op **ops, unsigned int num_bufs,
 	return 0;
 }
 
-/*
- * Compresses and decompresses buffer with compressdev API and Zlib API
+/**
+ * Initialize all the arrays used in comp/decomp to NULL.
+ *
+ * If the length is greater than the length of the last segment, the
+ * function will fail and return -1 without modifying the mbuf.
+ *
+ * @param prv
+ *   A container used for aggregation all the arrays.
+ * @param num_bufs
+ *   The number of elements in each array.
+ */
+static void
+test_objects_init(struct test_private_arrays *prv,
+		unsigned int num_bufs)
+{
+	/* Initialize all arrays to NULL */
+	memset(prv->uncomp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
+	memset(prv->comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
+	memset(prv->ops, 0, sizeof(struct rte_comp_op *) * num_bufs);
+	memset(prv->ops_processed, 0, sizeof(struct rte_comp_op *) * num_bufs);
+	memset(prv->priv_xforms, 0, sizeof(void *) * num_bufs);
+	memset(prv->compressed_data_size, 0, sizeof(uint32_t) * num_bufs);
+}
+
+/**
+ * Source buffers preparation (for compression).
+ *
+ * Memory allocation for each buffer from mempool
+ * -1 returned if function fail, without modifying the mbuf.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
  */
 static int
-test_deflate_comp_decomp(const struct interim_data_params *int_data,
-		const struct test_data_params *test_data)
+test_mbufs_source_preparation(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
 {
+	/* local variables: */
+	unsigned int i;
+	uint32_t data_size;
+	char *buf_ptr;
+	int ret;
+	char **all_decomp_data = priv_arrays->all_decomp_data;
+
 	struct comp_testsuite_params *ts_params = &testsuite_params;
+
+	/* from int_data: */
 	const char * const *test_bufs = int_data->test_bufs;
 	unsigned int num_bufs = int_data->num_bufs;
-	uint16_t *buf_idx = int_data->buf_idx;
-	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
-	struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms;
-	unsigned int num_xforms = int_data->num_xforms;
-	enum rte_comp_op_type compress_state = test_data->compress_state;
-	enum rte_comp_op_type decompress_state = test_data->decompress_state;
+
+	/* from test_data: */
 	unsigned int buff_type = test_data->buff_type;
-	unsigned int out_of_space = test_data->out_of_space;
 	unsigned int big_data = test_data->big_data;
-	enum zlib_direction zlib_dir = test_data->zlib_dir;
-	enum overflow_test overflow_tst = test_data->overflow;
-	int ret_status = TEST_FAILED;
-	struct rte_mbuf_ext_shared_info inbuf_info;
-	struct rte_mbuf_ext_shared_info compbuf_info;
-	struct rte_mbuf_ext_shared_info decompbuf_info;
-	int ret;
-	struct rte_mbuf *uncomp_bufs[num_bufs];
-	struct rte_mbuf *comp_bufs[num_bufs];
-	struct rte_comp_op *ops[num_bufs];
-	struct rte_comp_op *ops_processed[num_bufs];
-	void *priv_xforms[num_bufs];
-	uint16_t num_enqd, num_deqd, num_total_deqd;
-	uint16_t num_priv_xforms = 0;
-	unsigned int deqd_retries = 0;
-	struct priv_op_data *priv_data;
-	char *buf_ptr;
-	unsigned int i;
-	struct rte_mempool *buf_pool;
-	uint32_t data_size;
-	/* Compressing with CompressDev */
-	unsigned int oos_zlib_decompress =
-			(zlib_dir == ZLIB_NONE || zlib_dir == ZLIB_DECOMPRESS);
-	/* Decompressing with CompressDev */
-	unsigned int oos_zlib_compress =
-			(zlib_dir == ZLIB_NONE || zlib_dir == ZLIB_COMPRESS);
-	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];
-	uint32_t compressed_data_size[num_bufs];
-	void *stream = NULL;
-	char *all_decomp_data = NULL;
-	unsigned int decomp_produced_data_size = 0;
-	unsigned int step = 0;
 
-	TEST_ASSERT(decompress_state == RTE_COMP_OP_STATELESS || num_bufs == 1,
-		    "Number of stateful operations in a step should be 1");
+	/* from priv_arrays: */
+	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
+	struct rte_mempool *buf_pool;
 
-	if (capa == NULL) {
-		RTE_LOG(ERR, USER1,
-			"Compress device does not support DEFLATE\n");
-		return -ENOTSUP;
-	}
+	static struct rte_mbuf_ext_shared_info inbuf_info;
 
-	/* Initialize all arrays to NULL */
-	memset(uncomp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
-	memset(comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
-	memset(ops, 0, sizeof(struct rte_comp_op *) * num_bufs);
-	memset(ops_processed, 0, sizeof(struct rte_comp_op *) * num_bufs);
-	memset(priv_xforms, 0, sizeof(void *) * num_bufs);
-	memset(compressed_data_size, 0, sizeof(uint32_t) * num_bufs);
-
-	if (decompress_state == RTE_COMP_OP_STATEFUL) {
+	if (test_data->decompress_state == RTE_COMP_OP_STATEFUL) {
 		data_size = strlen(test_bufs[0]) + 1;
-		all_decomp_data = rte_malloc(NULL, data_size,
+		*all_decomp_data = rte_malloc(NULL, data_size,
 					     RTE_CACHE_LINE_SIZE);
 	}
 
@@ -861,14 +873,15 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	else
 		buf_pool = ts_params->large_mbuf_pool;
 
-	/* Prepare the source mbufs with the data */
+	/* for compression uncomp_bufs is used as a source buffer */
+	/* allocation from buf_pool (mempool type) */
 	ret = rte_pktmbuf_alloc_bulk(buf_pool,
 				uncomp_bufs, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Source mbufs could not be allocated "
 			"from the mempool\n");
-		goto exit;
+		return -1;
 	}
 
 	if (test_data->use_external_mbufs) {
@@ -881,8 +894,13 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 					test_data->inbuf_memzone->iova,
 					test_data->inbuf_data_size,
 					&inbuf_info);
-			rte_pktmbuf_append(uncomp_bufs[i],
+			buf_ptr = rte_pktmbuf_append(uncomp_bufs[i],
 					test_data->inbuf_data_size);
+			if (buf_ptr == NULL) {
+				RTE_LOG(ERR, USER1,
+					"Append extra bytes to the source mbuf failed\n");
+				return -1;
+			}
 		}
 	} else if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
 		for (i = 0; i < num_bufs; i++) {
@@ -893,106 +911,296 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 			    big_data ? buf_pool : ts_params->large_mbuf_pool,
 			    big_data ? 0 : MAX_SEGS,
 			    big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) < 0)
-				goto exit;
+				return -1;
 		}
 	} 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);
 			if (buf_ptr == NULL) {
 				RTE_LOG(ERR, USER1,
 					"Append extra bytes to the source mbuf failed\n");
-				goto exit;
+				return -1;
 			}
 			strlcpy(buf_ptr, test_bufs[i], data_size);
 		}
 	}
 
-	/* Prepare the destination mbufs */
-	ret = rte_pktmbuf_alloc_bulk(buf_pool, comp_bufs, num_bufs);
+	return 0;
+}
+
+/**
+ * Data size calculation (for both compression and decompression).
+ *
+ * Developer is requested to provide input params
+ * according to the following rule:
+ *      if ops_processed == NULL -> compression
+ *      if ops_processed != NULL -> decompression
+ * Values bigger than 0 have to be returned to avoid problems
+ * with memory allocation
+ *
+ * @param ops_processed
+ *   Operations created as a result of compression phase. Should be
+ *   set to NULL for compression
+ * @param out_of_space_and_zlib
+ *   Boolean value to switch into "out of space" buffer if set.
+ *   To test "out-of-space" data size, zlib_decompress must be set as well.
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param i
+ *   current buffer index
+ * @return
+ *   - values bigger than 0
+ */
+static inline uint32_t
+test_mbufs_calculate_data_size(
+		struct rte_comp_op *ops_processed[], /*can be equal to NULL*/
+		unsigned int out_of_space_and_zlib,
+		const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		unsigned int i)
+{
+	/* local variables: */
+	uint32_t data_size = 0;
+	struct priv_op_data *priv_data;
+	float ratio;
+	uint8_t not_zlib_compr; /* true if zlib isn't current compression dev */
+	enum overflow_test overflow = test_data->overflow;
+
+	/* from int_data: */
+	const char * const *test_bufs = int_data->test_bufs;
+
+	if (out_of_space_and_zlib)
+		data_size = OUT_OF_SPACE_BUF;
+	else {
+		if (ops_processed == NULL) {
+
+			not_zlib_compr = (test_data->zlib_dir == ZLIB_DECOMPRESS
+				|| test_data->zlib_dir == ZLIB_NONE);
+
+			ratio = (not_zlib_compr &&
+				(overflow == OVERFLOW_ENABLED)) ?
+				COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
+				COMPRESS_BUF_SIZE_RATIO;
+
+			data_size = strlen(test_bufs[i]) * ratio;
+
+		} else {
+			priv_data = (struct priv_op_data *)
+					(ops_processed[i] + 1);
+			data_size = strlen(test_bufs[priv_data->orig_idx]) + 1;
+		}
+	}
+
+	return data_size;
+}
+
+
+/**
+ * Memory buffers preparation (for both compression and decompression).
+ *
+ * Memory allocation for comp/decomp buffers from mempool, depending on
+ * ops_processed value. Developer is requested to provide input params
+ * according to the following rule:
+ *      if ops_processed == NULL -> current_bufs = comp_bufs[]
+ *      if ops_processed != NULL -> current_bufs = decomp_bufs[]
+ * -1 returned if function fail, without modifying the mbuf.
+ *
+ * @param ops_processed
+ *   Operations created as a result of compression phase. Should be
+ *   set to NULL for compression
+ * @param current_bufs
+ *   mbufs being prepared in the function.
+ * @param out_of_space_and_zlib
+ *   Boolean value to switch into "out of space" buffer if set.
+ *   To test "out-of-space" data size, zlib_decompress must be set as well.
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param current_extbuf_info,
+ *   The structure containing all the information related to external mbufs
+ * @param current_memzone
+ *   memzone used by external buffers
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_mbufs_destination_preparation(
+		struct rte_comp_op *ops_processed[], /*can be equal to NULL*/
+		struct rte_mbuf *current_bufs[],
+		unsigned int out_of_space_and_zlib,
+		const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		struct rte_mbuf_ext_shared_info *current_extbuf_info,
+		const struct rte_memzone *current_memzone)
+{
+	/* local variables: */
+	unsigned int i;
+	uint32_t data_size;
+	int ret;
+	char *buf_ptr;
+
+	struct comp_testsuite_params *ts_params = &testsuite_params;
+
+	/* from int_data: */
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from test_data: */
+	unsigned int buff_type = test_data->buff_type;
+	unsigned int big_data = test_data->big_data;
+
+	struct rte_mempool *buf_pool;
+
+	if (big_data)
+		buf_pool = ts_params->big_mbuf_pool;
+	else if (buff_type == SGL_BOTH)
+		buf_pool = ts_params->small_mbuf_pool;
+	else
+		buf_pool = ts_params->large_mbuf_pool;
+
+	/* the mbufs allocation*/
+	ret = rte_pktmbuf_alloc_bulk(buf_pool, current_bufs, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Destination mbufs could not be allocated "
 			"from the mempool\n");
-		goto exit;
+		return -1;
 	}
 
 	if (test_data->use_external_mbufs) {
-		compbuf_info.free_cb = extbuf_free_callback;
-		compbuf_info.fcb_opaque = NULL;
-		rte_mbuf_ext_refcnt_set(&compbuf_info, 1);
+		current_extbuf_info->free_cb = extbuf_free_callback;
+		current_extbuf_info->fcb_opaque = NULL;
+		rte_mbuf_ext_refcnt_set(current_extbuf_info, 1);
 		for (i = 0; i < num_bufs; i++) {
-			rte_pktmbuf_attach_extbuf(comp_bufs[i],
-					test_data->compbuf_memzone->addr,
-					test_data->compbuf_memzone->iova,
-					test_data->compbuf_memzone->len,
-					&compbuf_info);
-			rte_pktmbuf_append(comp_bufs[i],
-					test_data->compbuf_memzone->len);
+			rte_pktmbuf_attach_extbuf(current_bufs[i],
+					current_memzone->addr,
+					current_memzone->iova,
+					current_memzone->len,
+					current_extbuf_info);
+			rte_pktmbuf_append(current_bufs[i],
+					current_memzone->len);
 		}
-	} else if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
-		for (i = 0; i < num_bufs; i++) {
-			if (out_of_space == 1 && oos_zlib_decompress)
-				data_size = OUT_OF_SPACE_BUF;
-			else
-				(data_size = strlen(test_bufs[i]) *
-					COMPRESS_BUF_SIZE_RATIO);
-
-			if (prepare_sgl_bufs(NULL, comp_bufs[i],
-			      data_size,
-			      big_data ? buf_pool : ts_params->small_mbuf_pool,
-			      big_data ? buf_pool : ts_params->large_mbuf_pool,
-			      big_data ? 0 : MAX_SEGS,
-			      big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE)
-					< 0)
-				goto exit;
-		}
-
 	} else {
 		for (i = 0; i < num_bufs; i++) {
-			if (out_of_space == 1 && oos_zlib_decompress)
-				data_size = OUT_OF_SPACE_BUF;
-			else {
-				float ratio =
-				((test_data->zlib_dir == ZLIB_DECOMPRESS ||
-				   test_data->zlib_dir == ZLIB_NONE) &&
-				  overflow_tst == OVERFLOW_ENABLED) ?
-					 COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
-					 COMPRESS_BUF_SIZE_RATIO;
-
-				data_size = strlen(test_bufs[i]) * ratio;
-			}
-			buf_ptr = rte_pktmbuf_append(comp_bufs[i], data_size);
-			if (buf_ptr == NULL) {
-				RTE_LOG(ERR, USER1,
-					"Append extra bytes to the destination mbuf failed\n");
-				goto exit;
+
+			/* data size calculation */
+			data_size = test_mbufs_calculate_data_size(
+					ops_processed,
+					out_of_space_and_zlib,
+					int_data,
+					test_data,
+					i);
+
+			/* data allocation */
+			if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
+				ret = prepare_sgl_bufs(NULL, current_bufs[i],
+				      data_size,
+				      big_data ? buf_pool :
+						ts_params->small_mbuf_pool,
+				      big_data ? buf_pool :
+						ts_params->large_mbuf_pool,
+				      big_data ? 0 : MAX_SEGS,
+				      big_data ? MAX_DATA_MBUF_SIZE :
+						 SMALL_SEG_SIZE);
+				if (ret < 0)
+					return -1;
+			} else {
+				buf_ptr = rte_pktmbuf_append(current_bufs[i],
+						data_size);
+				if (buf_ptr == NULL) {
+					RTE_LOG(ERR, USER1,
+						"Append extra bytes to the destination mbuf failed\n");
+					return -1;
+				}
 			}
 		}
 	}
 
+	return 0;
+}
+
+/**
+ * The main compression function.
+ *
+ * Operation(s) configuration, depending on CLI parameters.
+ * Operation(s) processing.
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_comp_run(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
+{
+	/* local variables: */
+	struct priv_op_data *priv_data;
+	unsigned int i;
+	uint16_t num_priv_xforms = 0;
+	int ret;
+	int ret_status = 0;
+	char *buf_ptr;
+
+	struct comp_testsuite_params *ts_params = &testsuite_params;
+
+	/* from test_data: */
+	enum rte_comp_op_type operation_type = test_data->compress_state;
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+
+	/* from int_data: */
+	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
+	unsigned int num_xforms = int_data->num_xforms;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from priv_arrays: */
+	struct rte_mbuf **comp_bufs = priv_arrays->comp_bufs;
+	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
+	struct rte_comp_op **ops = priv_arrays->ops;
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
+	void **priv_xforms = priv_arrays->priv_xforms;
+
+	const struct rte_compressdev_capabilities *capa =
+		rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
+
 	/* Build the compression operations */
 	ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Compress operations could not be allocated "
 			"from the mempool\n");
+		ret_status = -1;
 		goto exit;
 	}
 
-
 	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;
-		if (compress_state == RTE_COMP_OP_STATELESS)
+
+		if (operation_type == RTE_COMP_OP_STATELESS) {
 			ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
-		else {
+		} else {
 			RTE_LOG(ERR, USER1,
-				"Stateful operations are not supported "
-				"in these tests yet\n");
+				"Compression: stateful operations are not "
+				"supported in these tests yet\n");
+			ret_status = -1;
 			goto exit;
 		}
 		ops[i]->input_chksum = 0;
@@ -1007,14 +1215,16 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	}
 
 	/* Compress data (either with Zlib API or compressdev API */
-	if (zlib_dir == ZLIB_COMPRESS || zlib_dir == ZLIB_ALL) {
+	if (zlib_compress) {
 		for (i = 0; i < num_bufs; i++) {
 			const struct rte_comp_xform *compress_xform =
 				compress_xforms[i % num_xforms];
 			ret = compress_zlib(ops[i], compress_xform,
 					DEFAULT_MEM_LEVEL);
-			if (ret < 0)
+			if (ret < 0) {
+				ret_status = -1;
 				goto exit;
+			}
 
 			ops_processed[i] = ops[i];
 		}
@@ -1022,24 +1232,26 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		/* Create compress private xform data */
 		for (i = 0; i < num_xforms; i++) {
 			ret = rte_compressdev_private_xform_create(0,
-				(const struct rte_comp_xform *)compress_xforms[i],
+				(const struct rte_comp_xform *)
+					compress_xforms[i],
 				&priv_xforms[i]);
 			if (ret < 0) {
 				RTE_LOG(ERR, USER1,
 					"Compression private xform "
 					"could not be created\n");
+				ret_status = -1;
 				goto exit;
 			}
 			num_priv_xforms++;
 		}
-
 		if (capa->comp_feature_flags &
 				RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
 			/* Attach shareable private xform data to ops */
 			for (i = 0; i < num_bufs; i++)
-				ops[i]->private_xform = priv_xforms[i % num_xforms];
+				ops[i]->private_xform =
+						priv_xforms[i % num_xforms];
 		} else {
-			/* Create rest of the private xforms for the other ops */
+		/* Create rest of the private xforms for the other ops */
 			for (i = num_xforms; i < num_bufs; i++) {
 				ret = rte_compressdev_private_xform_create(0,
 					compress_xforms[i % num_xforms],
@@ -1048,26 +1260,28 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 					RTE_LOG(ERR, USER1,
 						"Compression private xform "
 						"could not be created\n");
+					ret_status = -1;
 					goto exit;
 				}
 				num_priv_xforms++;
 			}
-
 			/* Attach non shareable private xform data to ops */
 			for (i = 0; i < num_bufs; i++)
 				ops[i]->private_xform = priv_xforms[i];
 		}
 
 recovery_lb:
-		ret = test_run_enqueue_dequeue(ops, num_bufs, ops_processed);
+		ret = test_run_enqueue_dequeue(ops, ops_processed, num_bufs);
 		if (ret < 0) {
 			RTE_LOG(ERR, USER1,
-				"Enqueue/dequeue operation failed\n");
+				"Compression: enqueue/dequeue operation failed\n");
+			ret_status = -1;
 			goto exit;
 		}
 
 		for (i = 0; i < num_bufs; i++) {
-			compressed_data_size[i] += ops_processed[i]->produced;
+			priv_arrays->compressed_data_size[i] +=
+					ops_processed[i]->produced;
 
 			if (ops_processed[i]->status ==
 				RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE) {
@@ -1088,21 +1302,83 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 				if (buf_ptr == NULL) {
 					RTE_LOG(ERR, USER1,
 						"Data recovery: append extra bytes to the current mbuf failed\n");
+					ret_status = -1;
 					goto exit;
 				}
 				goto recovery_lb;
 			}
 		}
-		deqd_retries = 0;
+	}
+
+exit:
+	/* Free resources */
+	if (ret_status < 0)
+		for (i = 0; i < num_bufs; i++) {
+			rte_comp_op_free(ops[i]);
+			ops_processed[i] = NULL;
+		}
 
-		/* Free compress private xforms */
-		for (i = 0; i < num_priv_xforms; i++) {
+	/* Free compress private xforms */
+	for (i = 0; i < num_priv_xforms; i++) {
+		if (priv_xforms[i] != NULL) {
 			rte_compressdev_private_xform_free(0, priv_xforms[i]);
 			priv_xforms[i] = NULL;
 		}
-		num_priv_xforms = 0;
 	}
 
+	return ret_status;
+}
+
+/**
+ * Prints out the test report. Memory freeing.
+ *
+ * Called after successful compression.
+ * Operation(s) status validation and decompression buffers freeing.
+
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 2: Some operation is not supported
+ *   - 1: Decompression should be skipped
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_comp_finalize(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
+{
+	/* local variables: */
+	unsigned int i;
+	struct priv_op_data *priv_data;
+
+	/* from int_data: */
+	unsigned int num_xforms = int_data->num_xforms;
+	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
+	uint16_t *buf_idx = int_data->buf_idx;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from priv_arrays: */
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
+	uint64_t *compress_checksum = priv_arrays->compress_checksum;
+	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
+	struct rte_comp_op **ops = priv_arrays->ops;
+
+	/* from test_data: */
+	unsigned int out_of_space = test_data->out_of_space;
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
+
 	for (i = 0; i < num_bufs; i++) {
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		uint16_t xform_idx = priv_data->orig_idx % num_xforms;
@@ -1111,7 +1387,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		enum rte_comp_huffman huffman_type =
 			compress_xform->deflate.huffman;
 		char engine[] = "zlib (directly, not PMD)";
-		if (zlib_dir != ZLIB_COMPRESS && zlib_dir != ZLIB_ALL)
+		if (zlib_decompress)
 			strlcpy(engine, "PMD", sizeof(engine));
 
 		RTE_LOG(DEBUG, USER1, "Buffer %u compressed by %s from %u to"
@@ -1134,116 +1410,103 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	 * compress operation information is needed for the decompression stage)
 	 */
 	for (i = 0; i < num_bufs; i++) {
-		if (out_of_space && oos_zlib_decompress) {
+		if (out_of_space && !zlib_compress) {
 			if (ops_processed[i]->status !=
 				RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
-				ret_status = TEST_FAILED;
 				RTE_LOG(ERR, USER1,
 					"Operation without expected out of "
 					"space status error\n");
-				goto exit;
+				return -1;
 			} else
 				continue;
 		}
 
 		if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) {
-			if (overflow_tst == OVERFLOW_ENABLED) {
+			if (test_data->overflow == OVERFLOW_ENABLED) {
 				if (ops_processed[i]->status ==
 				RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
-					ret_status = 1;
 					RTE_LOG(INFO, USER1,
 					"Out-of-space-recoverable functionality"
 					" is not supported on this device\n");
-					goto exit;
+					return 2;
 				}
 			}
+
 			RTE_LOG(ERR, USER1,
 				"Some operations were not successful\n");
-			goto exit;
+			return -1;
 		}
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		rte_pktmbuf_free(uncomp_bufs[priv_data->orig_idx]);
 		uncomp_bufs[priv_data->orig_idx] = NULL;
 	}
 
-	if (out_of_space && oos_zlib_decompress) {
-		ret_status = TEST_SUCCESS;
-		goto exit;
-	}
+	if (out_of_space && !zlib_compress)
+		return 1;
 
-	/* Allocate buffers for decompressed data */
-	ret = rte_pktmbuf_alloc_bulk(buf_pool, uncomp_bufs, num_bufs);
-	if (ret < 0) {
-		RTE_LOG(ERR, USER1,
-			"Destination mbufs could not be allocated "
-			"from the mempool\n");
-		goto exit;
-	}
+	return 0;
+}
 
-	if (test_data->use_external_mbufs) {
-		decompbuf_info.free_cb = extbuf_free_callback;
-		decompbuf_info.fcb_opaque = NULL;
-		rte_mbuf_ext_refcnt_set(&decompbuf_info, 1);
-		for (i = 0; i < num_bufs; i++) {
-			rte_pktmbuf_attach_extbuf(uncomp_bufs[i],
-					test_data->uncompbuf_memzone->addr,
-					test_data->uncompbuf_memzone->iova,
-					test_data->uncompbuf_memzone->len,
-					&decompbuf_info);
-			rte_pktmbuf_append(uncomp_bufs[i],
-					test_data->uncompbuf_memzone->len);
-		}
-	} else if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
-		for (i = 0; i < num_bufs; i++) {
-			priv_data = (struct priv_op_data *)
-					(ops_processed[i] + 1);
-			if (out_of_space == 1 && oos_zlib_compress)
-				data_size = OUT_OF_SPACE_BUF;
-			else if (test_data->decompress_output_block_size != 0)
-				data_size =
-					test_data->decompress_output_block_size;
-			else
-				data_size =
-				strlen(test_bufs[priv_data->orig_idx]) + 1;
-
-			if (prepare_sgl_bufs(NULL, uncomp_bufs[i],
-			       data_size,
-			       big_data ? buf_pool : ts_params->small_mbuf_pool,
-			       big_data ? buf_pool : ts_params->large_mbuf_pool,
-			       big_data ? 0 : MAX_SEGS,
-			       big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE)
-					< 0)
-				goto exit;
-		}
+/**
+ * The main decompression function.
+ *
+ * Operation(s) configuration, depending on CLI parameters.
+ * Operation(s) processing.
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_decomp_run(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		struct test_private_arrays *priv_arrays)
+{
 
-	} else {
-		for (i = 0; i < num_bufs; i++) {
-			priv_data = (struct priv_op_data *)
-					(ops_processed[i] + 1);
-			if (out_of_space == 1 && oos_zlib_compress)
-				data_size = OUT_OF_SPACE_BUF;
-			else if (test_data->decompress_output_block_size != 0)
-				data_size =
-					test_data->decompress_output_block_size;
-			else
-				data_size =
-				strlen(test_bufs[priv_data->orig_idx]) + 1;
+	/* local variables: */
+	struct priv_op_data *priv_data;
+	unsigned int i;
+	uint16_t num_priv_xforms = 0;
+	int ret;
+	int ret_status = 0;
 
-			buf_ptr = rte_pktmbuf_append(uncomp_bufs[i], data_size);
-			if (buf_ptr == NULL) {
-				RTE_LOG(ERR, USER1,
-					"Append extra bytes to the decompressed mbuf failed\n");
-				goto exit;
-			}
-		}
-	}
+	struct comp_testsuite_params *ts_params = &testsuite_params;
+
+	/* from test_data: */
+	enum rte_comp_op_type operation_type = test_data->decompress_state;
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
+
+	/* from int_data: */
+	struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms;
+	unsigned int num_xforms = int_data->num_xforms;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from priv_arrays: */
+	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
+	struct rte_comp_op **ops = priv_arrays->ops;
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
+	void **priv_xforms = priv_arrays->priv_xforms;
+	uint32_t *compressed_data_size = priv_arrays->compressed_data_size;
+	void **stream = priv_arrays->stream;
+
+	const struct rte_compressdev_capabilities *capa =
+		rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
 
-	/* Build the decompression operations */
 	ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Decompress operations could not be allocated "
 			"from the mempool\n");
+		ret_status = -1;
 		goto exit;
 	}
 
@@ -1256,22 +1519,25 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		 * Set the length of the compressed data to the
 		 * number of bytes that were produced in the previous stage
 		 */
+
 		if (compressed_data_size[i])
 			ops[i]->src.length = compressed_data_size[i];
 		else
 			ops[i]->src.length = ops_processed[i]->produced;
 
 		ops[i]->dst.offset = 0;
-		if (decompress_state == RTE_COMP_OP_STATELESS) {
+
+		if (operation_type == RTE_COMP_OP_STATELESS) {
 			ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
 			ops[i]->op_type = RTE_COMP_OP_STATELESS;
-		} else if (zlib_dir == ZLIB_COMPRESS || zlib_dir == ZLIB_NONE) {
+		} else if (!zlib_decompress) {
 			ops[i]->flush_flag = RTE_COMP_FLUSH_SYNC;
 			ops[i]->op_type = RTE_COMP_OP_STATEFUL;
 		} else {
 			RTE_LOG(ERR, USER1,
-				"Stateful operations are not supported "
-				"in these tests yet\n");
+				"Decompression: stateful operations are"
+				" not supported in these tests yet\n");
+			ret_status = -1;
 			goto exit;
 		}
 		ops[i]->input_chksum = 0;
@@ -1290,7 +1556,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	rte_comp_op_bulk_free(ops_processed, num_bufs);
 
 	/* Decompress data (either with Zlib API or compressdev API */
-	if (zlib_dir == ZLIB_DECOMPRESS || zlib_dir == ZLIB_ALL) {
+	if (zlib_decompress) {
 		for (i = 0; i < num_bufs; i++) {
 			priv_data = (struct priv_op_data *)(ops[i] + 1);
 			uint16_t xform_idx = priv_data->orig_idx % num_xforms;
@@ -1298,13 +1564,15 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 				decompress_xforms[xform_idx];
 
 			ret = decompress_zlib(ops[i], decompress_xform);
-			if (ret < 0)
+			if (ret < 0) {
+				ret_status = -1;
 				goto exit;
+			}
 
 			ops_processed[i] = ops[i];
 		}
 	} else {
-		if (decompress_state == RTE_COMP_OP_STATELESS) {
+		if (operation_type == RTE_COMP_OP_STATELESS) {
 			/* Create decompress private xform data */
 			for (i = 0; i < num_xforms; i++) {
 				ret = rte_compressdev_private_xform_create(0,
@@ -1315,6 +1583,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 					RTE_LOG(ERR, USER1,
 						"Decompression private xform "
 						"could not be created\n");
+					ret_status = -1;
 					goto exit;
 				}
 				num_priv_xforms++;
@@ -1341,7 +1610,9 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 					      &priv_xforms[i]);
 					if (ret < 0) {
 						RTE_LOG(ERR, USER1,
-							"Decompression private xform could not be created\n");
+							"Decompression private xform"
+							" could not be created\n");
+						ret_status = -1;
 						goto exit;
 					}
 					num_priv_xforms++;
@@ -1361,59 +1632,86 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		} else {
 			/* Create a stream object for stateful decompression */
 			ret = rte_compressdev_stream_create(0,
-					decompress_xforms[0], &stream);
+					decompress_xforms[0], stream);
 			if (ret < 0) {
 				RTE_LOG(ERR, USER1,
 					"Decompression stream could not be created, error %d\n",
 					ret);
+				ret_status = -1;
 				goto exit;
 			}
 			/* Attach stream to ops */
 			for (i = 0; i < num_bufs; i++)
-				ops[i]->stream = stream;
+				ops[i]->stream = *stream;
 		}
 
-next_step:
-		/* Enqueue and dequeue all operations */
-		num_enqd = rte_compressdev_enqueue_burst(0, 0, ops, num_bufs);
-		if (num_enqd < num_bufs) {
-			RTE_LOG(ERR, USER1,
-				"The operations could not be enqueued\n");
-			goto exit;
-		}
+		priv_arrays->num_priv_xforms = num_priv_xforms;
+	}
 
-		num_total_deqd = 0;
-		do {
-			/*
-			 * If retrying a dequeue call, wait for 10 ms to allow
-			 * enough time to the driver to process the operations
-			 */
-			if (deqd_retries != 0) {
-				/*
-				 * Avoid infinite loop if not all the
-				 * operations get out of the device
-				 */
-				if (deqd_retries == MAX_DEQD_RETRIES) {
-					RTE_LOG(ERR, USER1,
-						"Not all operations could be "
-						"dequeued\n");
-					goto exit;
-				}
-				usleep(DEQUEUE_WAIT_TIME);
-			}
-			num_deqd = rte_compressdev_dequeue_burst(0, 0,
-					&ops_processed[num_total_deqd], num_bufs);
-			num_total_deqd += num_deqd;
-			deqd_retries++;
-		} while (num_total_deqd < num_enqd);
+exit:
+	return ret_status;
+}
 
-		deqd_retries = 0;
-	}
+/**
+ * Prints out the test report. Memory freeing.
+ *
+ * Called after successful decompression.
+ * Operation(s) status validation and compression buffers freeing.
+
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 2: Next step must be executed by the caller (stateful decompression only)
+ *   - 1: On success (caller should stop and exit)
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_decomp_finalize(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
+{
+	/* local variables: */
+	unsigned int i;
+	struct priv_op_data *priv_data;
+	static unsigned int step;
+
+	/* from int_data: */
+	uint16_t *buf_idx = int_data->buf_idx;
+	unsigned int num_bufs = int_data->num_bufs;
+	const char * const *test_bufs = int_data->test_bufs;
+	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
+
+	/* from priv_arrays: */
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
+	struct rte_mbuf **comp_bufs = priv_arrays->comp_bufs;
+	struct rte_comp_op **ops = priv_arrays->ops;
+	uint64_t *compress_checksum = priv_arrays->compress_checksum;
+	unsigned int *decomp_produced_data_size =
+			priv_arrays->decomp_produced_data_size;
+	char **all_decomp_data = priv_arrays->all_decomp_data;
+
+	/* from test_data: */
+	unsigned int out_of_space = test_data->out_of_space;
+	enum rte_comp_op_type operation_type = test_data->decompress_state;
+
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
 
 	for (i = 0; i < num_bufs; i++) {
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		char engine[] = "zlib, (directly, no PMD)";
-		if (zlib_dir != ZLIB_DECOMPRESS && zlib_dir != ZLIB_ALL)
+		if (zlib_compress)
 			strlcpy(engine, "pmd", sizeof(engine));
 		RTE_LOG(DEBUG, USER1,
 			"Buffer %u decompressed by %s from %u to %u bytes\n",
@@ -1427,19 +1725,19 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	 * compress operation information is still needed)
 	 */
 	for (i = 0; i < num_bufs; i++) {
-		if (out_of_space && oos_zlib_compress) {
+		if (out_of_space && !zlib_decompress) {
 			if (ops_processed[i]->status !=
-					RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
-				ret_status = TEST_FAILED;
+				RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
+
 				RTE_LOG(ERR, USER1,
 					"Operation without expected out of "
 					"space status error\n");
-				goto exit;
+				return -1;
 			} else
 				continue;
 		}
 
-		if (decompress_state == RTE_COMP_OP_STATEFUL
+		if (operation_type == RTE_COMP_OP_STATEFUL
 			&& (ops_processed[i]->status ==
 				RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE
 			    || ops_processed[i]->status ==
@@ -1449,28 +1747,29 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 					ops_processed[i]->m_dst,
 					ops_processed[i]->dst.offset,
 					ops_processed[i]->produced,
-					all_decomp_data +
-						decomp_produced_data_size);
-			if (ptr != all_decomp_data + decomp_produced_data_size)
-				rte_memcpy(all_decomp_data +
-					   decomp_produced_data_size,
+					*all_decomp_data +
+						*decomp_produced_data_size);
+			if (ptr != *all_decomp_data +
+					*decomp_produced_data_size)
+				rte_memcpy(*all_decomp_data +
+					   *decomp_produced_data_size,
 					   ptr, ops_processed[i]->produced);
-			decomp_produced_data_size += ops_processed[i]->produced;
+
+			*decomp_produced_data_size +=
+					ops_processed[i]->produced;
 			if (ops_processed[i]->src.length >
 					ops_processed[i]->consumed) {
 				if (ops_processed[i]->status ==
 						RTE_COMP_OP_STATUS_SUCCESS) {
-					ret_status = -1;
 					RTE_LOG(ERR, USER1,
 					      "Operation finished too early\n");
-					goto exit;
+					return -1;
 				}
 				step++;
 				if (step >= test_data->decompress_steps_max) {
-					ret_status = -1;
 					RTE_LOG(ERR, USER1,
 					  "Operation exceeded maximum steps\n");
-					goto exit;
+					return -1;
 				}
 				ops[i] = ops_processed[i];
 				ops[i]->status =
@@ -1479,7 +1778,9 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 						ops_processed[i]->consumed;
 				ops[i]->src.length -=
 						ops_processed[i]->consumed;
-				goto next_step;
+				/* repeat the operation */
+				//goto next_step;
+				return 2;
 			} else {
 				/* Compare the original stream with the */
 				/* decompressed stream (in size and the data) */
@@ -1487,22 +1788,22 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 						(ops_processed[i] + 1);
 				const char *buf1 =
 						test_bufs[priv_data->orig_idx];
-				const char *buf2 = all_decomp_data;
+				const char *buf2 = *all_decomp_data;
 
 				if (compare_buffers(buf1, strlen(buf1) + 1,
-					  buf2, decomp_produced_data_size) < 0)
-					goto exit;
+					  buf2, *decomp_produced_data_size) < 0)
+					return -1;
 				/* 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],
+			"The checksums differ\n"
+			"Compression Checksum: %" PRIu64 "\tDecompression "
+			"Checksum: %" PRIu64 "\n", compress_checksum[i],
 					       ops_processed[i]->output_chksum);
-						goto exit;
+						return -1;
 					}
 				}
 			}
@@ -1510,18 +1811,58 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 			   RTE_COMP_OP_STATUS_SUCCESS) {
 			RTE_LOG(ERR, USER1,
 				"Some operations were not successful\n");
-			goto exit;
+			return -1;
 		}
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		rte_pktmbuf_free(comp_bufs[priv_data->orig_idx]);
 		comp_bufs[priv_data->orig_idx] = NULL;
 	}
 
-	if ((out_of_space && oos_zlib_compress)
-			|| (decompress_state == RTE_COMP_OP_STATEFUL)) {
-		ret_status = TEST_SUCCESS;
-		goto exit;
-	}
+	if (out_of_space && !zlib_decompress)
+		return 1;
+
+	return 0;
+}
+
+/**
+ * Validation of the output (compression/decompression) data.
+ *
+ * The function compares the source stream with the output stream,
+ * after decompression, to check if compression/decompression
+ * was correct.
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param priv_arrays
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_results_validation(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *priv_arrays)
+{
+	/* local variables: */
+	unsigned int i;
+	struct priv_op_data *priv_data;
+	const char *buf1;
+	const char *buf2;
+	char *contig_buf = NULL;
+	uint32_t data_size;
+
+	/* from int_data: */
+	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
+	unsigned int num_bufs = int_data->num_bufs;
+	const char * const *test_bufs = int_data->test_bufs;
+
+	/* from priv_arrays: */
+	uint64_t *compress_checksum = priv_arrays->compress_checksum;
+	struct rte_comp_op **ops_processed = priv_arrays->ops_processed;
 
 	/*
 	 * Compare the original stream with the decompressed stream
@@ -1529,13 +1870,13 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	 */
 	for (i = 0; i < num_bufs; i++) {
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
-		const char *buf1 = test_data->use_external_mbufs ?
+		buf1 = test_data->use_external_mbufs ?
 				test_data->inbuf_memzone->addr :
 				test_bufs[priv_data->orig_idx];
-		const char *buf2;
 		data_size = test_data->use_external_mbufs ?
 				test_data->inbuf_data_size :
 				strlen(buf1) + 1;
+
 		contig_buf = rte_malloc(NULL, ops_processed[i]->produced, 0);
 		if (contig_buf == NULL) {
 			RTE_LOG(ERR, USER1, "Contiguous buffer could not "
@@ -1565,24 +1906,207 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		rte_free(contig_buf);
 		contig_buf = NULL;
 	}
+	return 0;
+
+exit:
+	rte_free(contig_buf);
+	return -1;
+}
+
+/**
+ * Compresses and decompresses input stream with compressdev API and Zlib API
+ *
+ * Basic test function. Common for all the functional tests.
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @return
+ *   - 1: Some operation not supported
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+
+static int
+test_deflate_comp_decomp(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data)
+{
+	unsigned int num_bufs = int_data->num_bufs;
+	unsigned int out_of_space = test_data->out_of_space;
+
+	void *stream = NULL;
+	char *all_decomp_data = NULL;
+	unsigned int decomp_produced_data_size = 0;
+
+	int ret_status = -1;
+	int ret;
+	struct rte_mbuf *uncomp_bufs[num_bufs];
+	struct rte_mbuf *comp_bufs[num_bufs];
+	struct rte_comp_op *ops[num_bufs];
+	struct rte_comp_op *ops_processed[num_bufs];
+	void *priv_xforms[num_bufs];
+	unsigned int i;
+
+	uint64_t compress_checksum[num_bufs];
+	uint32_t compressed_data_size[num_bufs];
+	char *contig_buf = NULL;
+
+	struct rte_mbuf_ext_shared_info compbuf_info;
+	struct rte_mbuf_ext_shared_info decompbuf_info;
+
+	const struct rte_compressdev_capabilities *capa;
+
+	/* Compressing with CompressDev */
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
+
+	struct test_private_arrays priv_arrays;
+
+	priv_arrays.uncomp_bufs = uncomp_bufs;
+	priv_arrays.comp_bufs = comp_bufs;
+	priv_arrays.ops = ops;
+	priv_arrays.ops_processed = ops_processed;
+	priv_arrays.priv_xforms = priv_xforms;
+	priv_arrays.compress_checksum = compress_checksum;
+	priv_arrays.compressed_data_size = compressed_data_size;
+
+	priv_arrays.stream = &stream;
+	priv_arrays.all_decomp_data = &all_decomp_data;
+	priv_arrays.decomp_produced_data_size = &decomp_produced_data_size;
+
+	priv_arrays.num_priv_xforms = 0; /* it's used for deompression only */
+
+	capa = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
+	if (capa == NULL) {
+		RTE_LOG(ERR, USER1,
+			"Compress device does not support DEFLATE\n");
+		return -1;
+	}
+	test_objects_init(&priv_arrays, num_bufs);
+
+	/* Prepare the source mbufs with the data */
+	ret = test_mbufs_source_preparation(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+/* COMPRESSION  */
+
+	/* Prepare the destination mbufs */
+	ret = test_mbufs_destination_preparation(
+			NULL, /*can be equal to NULL*/
+			comp_bufs,
+			out_of_space == 1 && !zlib_compress,
+			int_data,
+			test_data,
+			&compbuf_info,
+			test_data->compbuf_memzone);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	/* Run compression */
+	ret = test_deflate_comp_run(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	ret = test_deflate_comp_finalize(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	} else if (ret == 1) {
+		ret_status = 0;
+		goto exit;
+	} else if (ret == 2) {
+		ret_status = 1;	 /* some operation not supported */
+		goto exit;
+	}
+
+/* DECOMPRESSION  */
+
+	/* Allocate buffers for decompressed data */
+	ret = test_mbufs_destination_preparation(
+			ops_processed, /*can be equal to NULL*/
+			uncomp_bufs,
+			out_of_space == 1 && !zlib_decompress,
+			int_data,
+			test_data,
+			&decompbuf_info,
+			test_data->uncompbuf_memzone);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	/* Run decompression */
+	ret = test_deflate_decomp_run(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	if (!zlib_decompress) {
+next_step:	/* next step for stateful decompression only */
+		ret = test_run_enqueue_dequeue(ops, ops_processed, num_bufs);
+		if (ret < 0) {
+			ret_status = -1;
+			RTE_LOG(ERR, USER1,
+				"Decompression: enqueue/dequeue operation failed\n");
+		}
+	}
 
-	ret_status = TEST_SUCCESS;
+	ret = test_deflate_decomp_finalize(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	} else if (ret == 1) {
+		ret_status = 0;
+		goto exit;
+	} else if (ret == 2) {
+		goto next_step;
+	}
+
+/* FINAL PROCESSING  */
+
+	ret = test_results_validation(int_data, test_data, &priv_arrays);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+	ret_status = 0;
 
 exit:
 	/* Free resources */
+
+	if (stream != NULL)
+		rte_compressdev_stream_free(0, stream);
+	if (all_decomp_data != NULL)
+		rte_free(all_decomp_data);
+
+	/* Free compress private xforms */
+	for (i = 0; i < priv_arrays.num_priv_xforms; i++) {
+		if (priv_xforms[i] != NULL) {
+			rte_compressdev_private_xform_free(0, priv_xforms[i]);
+			priv_xforms[i] = NULL;
+		}
+	}
+
 	for (i = 0; i < num_bufs; i++) {
 		rte_pktmbuf_free(uncomp_bufs[i]);
 		rte_pktmbuf_free(comp_bufs[i]);
 		rte_comp_op_free(ops[i]);
 		rte_comp_op_free(ops_processed[i]);
 	}
-	for (i = 0; i < num_priv_xforms; i++)
-		if (priv_xforms[i] != NULL)
-			rte_compressdev_private_xform_free(0, priv_xforms[i]);
-	if (stream != NULL)
-		rte_compressdev_stream_free(0, stream);
-	if (all_decomp_data != NULL)
-		rte_free(all_decomp_data);
 	rte_free(contig_buf);
 
 	return ret_status;
diff --git a/doc/guides/rel_notes/release_19_11.rst b/doc/guides/rel_notes/release_19_11.rst
index 066bb3c19..5906f8b94 100644
--- a/doc/guides/rel_notes/release_19_11.rst
+++ b/doc/guides/rel_notes/release_19_11.rst
@@ -152,6 +152,11 @@ New Features
   Added eBPF JIT support for arm64 architecture to improve the eBPF program
   performance.
 
+* **Refactored compression unit tests.**
+
+  Refactored core function to get clear code structure, better for maintenance.
+  Created smaller specialized functions.
+
 
 Removed Items
 -------------
-- 
2.17.1

Re: [dpdk-dev] [PATCH v3 1/1] test/compress: unit tests refactoring

[Dybkowski, AdamX]

> -----Original Message-----
> From: Trybula, ArturX
> Sent: Thursday, 24 October, 2019 11:16
> To: dev@dpdk.org; Trahe, Fiona <fiona.trahe@intel.com>;
> shallyv@marvell.com; Dybkowski, AdamX <adamx.dybkowski@intel.com>;
> Trybula, ArturX <arturx.trybula@intel.com>; akhil.goyal@nxp.com
> Subject: [PATCH v3 1/1] test/compress: unit tests refactoring
> 
> Core engine refactoring (test_deflate_comp_decomp function).
> Smaller specialized functions created.
> 
> Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
> ---

Acked-by: Adam Dybkowski <adamx.dybkowski@intel.com>

Re: [dpdk-dev] [PATCH v3 1/1] test/compress: unit tests refactoring

[Akhil Goyal]

> 
> Core engine refactoring (test_deflate_comp_decomp function).
> Smaller specialized functions created.
> 
> Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
> ---

This patch would need an ack from both Marvell and Intel before RC2(8th Nov 19)

Re: [dpdk-dev] [PATCH v3 1/1] test/compress: unit tests refactoring

[Akhil Goyal]

Hi Shally,

Could you please review this patch?

Thanks,
Akhil

> -----Original Message-----
> From: dev <dev-bounces@dpdk.org> On Behalf Of Akhil Goyal
> Sent: Thursday, October 24, 2019 2:57 PM
> To: Artur Trybula <arturx.trybula@intel.com>; dev@dpdk.org;
> fiona.trahe@intel.com; shallyv@marvell.com; adamx.dybkowski@intel.com
> Subject: Re: [dpdk-dev] [PATCH v3 1/1] test/compress: unit tests refactoring
> 
> 
> >
> > Core engine refactoring (test_deflate_comp_decomp function).
> > Smaller specialized functions created.
> >
> > Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
> > ---
> 
> This patch would need an ack from both Marvell and Intel before RC2(8th Nov
> 19)

Re: [dpdk-dev] [EXT] [PATCH v3 1/1] test/compress: unit tests refactoring

[Shally Verma]

> -----Original Message-----
> From: Artur Trybula <arturx.trybula@intel.com>
> Sent: Thursday, October 24, 2019 2:46 PM
> To: dev@dpdk.org; fiona.trahe@intel.com; Shally Verma
> <shallyv@marvell.com>; adamx.dybkowski@intel.com;
> arturx.trybula@intel.com; akhil.goyal@nxp.com
> Subject: [EXT] [PATCH v3 1/1] test/compress: unit tests refactoring
> 
> External Email
> 
> ----------------------------------------------------------------------
> Core engine refactoring (test_deflate_comp_decomp function).
> Smaller specialized functions created.
> 
> Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
> ---
>  app/test/test_compressdev.c            | 1118 +++++++++++++++++-------
>  doc/guides/rel_notes/release_19_11.rst |    5 +
>  2 files changed, 826 insertions(+), 297 deletions(-)
> 
> diff --git a/app/test/test_compressdev.c b/app/test/test_compressdev.c
> index 283c64971..4932bec76 100644
> --- a/app/test/test_compressdev.c
> +++ b/app/test/test_compressdev.c
> @@ -120,6 +120,20 @@ struct test_data_params {
>  	enum overflow_test overflow;
>  };
> 
> +struct test_private_arrays {
> +	struct rte_mbuf **uncomp_bufs;
> +	struct rte_mbuf **comp_bufs;
> +	struct rte_comp_op **ops;
> +	struct rte_comp_op **ops_processed;
> +	void **priv_xforms;
> +	uint64_t *compress_checksum;
> +	uint32_t *compressed_data_size;
> +	void **stream;
> +	char **all_decomp_data;
> +	unsigned int *decomp_produced_data_size;
> +	uint16_t num_priv_xforms;
> +};
> +
>  static struct comp_testsuite_params testsuite_params = { 0 };
> 
>  static void
> @@ -662,6 +676,7 @@ prepare_sgl_bufs(const char *test_buf, struct
> rte_mbuf *head_buf,
>  		data_size = remaining_data;
>  	else
>  		data_size = seg_size;
> +
>  	buf_ptr = rte_pktmbuf_append(head_buf, data_size);
>  	if (buf_ptr == NULL) {
>  		RTE_LOG(ERR, USER1,
> @@ -734,8 +749,9 @@ extbuf_free_callback(void *addr __rte_unused, void
> *opaque __rte_unused)  }
> 
>  static int
> -test_run_enqueue_dequeue(struct rte_comp_op **ops, unsigned int
> num_bufs,
> -		  struct rte_comp_op **ops_processed)
> +test_run_enqueue_dequeue(struct rte_comp_op **ops,
> +			 struct rte_comp_op **ops_processed,
> +			 unsigned int num_bufs)
>  {
>  	uint16_t num_enqd, num_deqd, num_total_deqd;
>  	unsigned int deqd_retries = 0;
> @@ -776,81 +792,77 @@ test_run_enqueue_dequeue(struct rte_comp_op
> **ops, unsigned int num_bufs,
>  	return 0;
>  }
> 
> -/*
> - * Compresses and decompresses buffer with compressdev API and Zlib API
> +/**
> + * Initialize all the arrays used in comp/decomp to NULL.
> + *
> + * If the length is greater than the length of the last segment, the
> + * function will fail and return -1 without modifying the mbuf.
> + *
> + * @param prv
> + *   A container used for aggregation all the arrays.
> + * @param num_bufs
> + *   The number of elements in each array.
> + */
> +static void
> +test_objects_init(struct test_private_arrays *prv,
> +		unsigned int num_bufs)
> +{
> +	/* Initialize all arrays to NULL */
> +	memset(prv->uncomp_bufs, 0, sizeof(struct rte_mbuf *) *
> num_bufs);
> +	memset(prv->comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
> +	memset(prv->ops, 0, sizeof(struct rte_comp_op *) * num_bufs);
> +	memset(prv->ops_processed, 0, sizeof(struct rte_comp_op *) *
> num_bufs);
> +	memset(prv->priv_xforms, 0, sizeof(void *) * num_bufs);
> +	memset(prv->compressed_data_size, 0, sizeof(uint32_t) *
> num_bufs); }
> +
Does it really matter what pointer is pointing to? Sizeof(any pointer) * num_bufs .. should be enough.

> +/**
> + * Source buffers preparation (for compression).
> + *
> + * Memory allocation for each buffer from mempool
> + * -1 returned if function fail, without modifying the mbuf.
> + *
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param priv_arrays
> + *   A container used for aggregation all the private test arrays.
> + * @return
> + *   - 0: On success.
> + *   - -1: On error.
>   */
>  static int
> -test_deflate_comp_decomp(const struct interim_data_params *int_data,
> -		const struct test_data_params *test_data)
> +test_mbufs_source_preparation(const struct interim_data_params
> *int_data,
> +		const struct test_data_params *test_data,
> +		const struct test_private_arrays *priv_arrays)
>  {
> +	/* local variables: */
> +	unsigned int i;
> +	uint32_t data_size;
> +	char *buf_ptr;
> +	int ret;
> +	char **all_decomp_data = priv_arrays->all_decomp_data;
> +
>  	struct comp_testsuite_params *ts_params = &testsuite_params;
> +
> +	/* from int_data: */
>  	const char * const *test_bufs = int_data->test_bufs;
>  	unsigned int num_bufs = int_data->num_bufs;
> -	uint16_t *buf_idx = int_data->buf_idx;
> -	struct rte_comp_xform **compress_xforms = int_data-
> >compress_xforms;
> -	struct rte_comp_xform **decompress_xforms = int_data-
> >decompress_xforms;
> -	unsigned int num_xforms = int_data->num_xforms;
> -	enum rte_comp_op_type compress_state = test_data-
> >compress_state;
> -	enum rte_comp_op_type decompress_state = test_data-
> >decompress_state;
> +
> +	/* from test_data: */
>  	unsigned int buff_type = test_data->buff_type;
> -	unsigned int out_of_space = test_data->out_of_space;
>  	unsigned int big_data = test_data->big_data;
> -	enum zlib_direction zlib_dir = test_data->zlib_dir;
> -	enum overflow_test overflow_tst = test_data->overflow;
> -	int ret_status = TEST_FAILED;
> -	struct rte_mbuf_ext_shared_info inbuf_info;
> -	struct rte_mbuf_ext_shared_info compbuf_info;
> -	struct rte_mbuf_ext_shared_info decompbuf_info;
> -	int ret;
> -	struct rte_mbuf *uncomp_bufs[num_bufs];
> -	struct rte_mbuf *comp_bufs[num_bufs];
> -	struct rte_comp_op *ops[num_bufs];
> -	struct rte_comp_op *ops_processed[num_bufs];
> -	void *priv_xforms[num_bufs];
> -	uint16_t num_enqd, num_deqd, num_total_deqd;
> -	uint16_t num_priv_xforms = 0;
> -	unsigned int deqd_retries = 0;
> -	struct priv_op_data *priv_data;
> -	char *buf_ptr;
> -	unsigned int i;
> -	struct rte_mempool *buf_pool;
> -	uint32_t data_size;
> -	/* Compressing with CompressDev */
> -	unsigned int oos_zlib_decompress =
> -			(zlib_dir == ZLIB_NONE || zlib_dir ==
> ZLIB_DECOMPRESS);
> -	/* Decompressing with CompressDev */
> -	unsigned int oos_zlib_compress =
> -			(zlib_dir == ZLIB_NONE || zlib_dir ==
> ZLIB_COMPRESS);
> -	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];
> -	uint32_t compressed_data_size[num_bufs];
> -	void *stream = NULL;
> -	char *all_decomp_data = NULL;
> -	unsigned int decomp_produced_data_size = 0;
> -	unsigned int step = 0;
> 
> -	TEST_ASSERT(decompress_state == RTE_COMP_OP_STATELESS ||
> num_bufs == 1,
> -		    "Number of stateful operations in a step should be 1");
> +	/* from priv_arrays: */
> +	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
> +	struct rte_mempool *buf_pool;
> 
> -	if (capa == NULL) {
> -		RTE_LOG(ERR, USER1,
> -			"Compress device does not support DEFLATE\n");
> -		return -ENOTSUP;
> -	}
> +	static struct rte_mbuf_ext_shared_info inbuf_info;
> 
> -	/* Initialize all arrays to NULL */
> -	memset(uncomp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
> -	memset(comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
> -	memset(ops, 0, sizeof(struct rte_comp_op *) * num_bufs);
> -	memset(ops_processed, 0, sizeof(struct rte_comp_op *) *
> num_bufs);
> -	memset(priv_xforms, 0, sizeof(void *) * num_bufs);
> -	memset(compressed_data_size, 0, sizeof(uint32_t) * num_bufs);
> -
> -	if (decompress_state == RTE_COMP_OP_STATEFUL) {
> +	if (test_data->decompress_state == RTE_COMP_OP_STATEFUL) {
>  		data_size = strlen(test_bufs[0]) + 1;
> -		all_decomp_data = rte_malloc(NULL, data_size,
> +		*all_decomp_data = rte_malloc(NULL, data_size,
>  					     RTE_CACHE_LINE_SIZE);
>  	}
> 
> @@ -861,14 +873,15 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  	else
>  		buf_pool = ts_params->large_mbuf_pool;
> 
> -	/* Prepare the source mbufs with the data */
> +	/* for compression uncomp_bufs is used as a source buffer */
> +	/* allocation from buf_pool (mempool type) */
>  	ret = rte_pktmbuf_alloc_bulk(buf_pool,
>  				uncomp_bufs, num_bufs);
>  	if (ret < 0) {
>  		RTE_LOG(ERR, USER1,
>  			"Source mbufs could not be allocated "
>  			"from the mempool\n");
> -		goto exit;
> +		return -1;
>  	}
> 
>  	if (test_data->use_external_mbufs) {
> @@ -881,8 +894,13 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  					test_data->inbuf_memzone->iova,
>  					test_data->inbuf_data_size,
>  					&inbuf_info);
> -			rte_pktmbuf_append(uncomp_bufs[i],
> +			buf_ptr = rte_pktmbuf_append(uncomp_bufs[i],
>  					test_data->inbuf_data_size);
> +			if (buf_ptr == NULL) {
> +				RTE_LOG(ERR, USER1,
> +					"Append extra bytes to the source
> mbuf failed\n");
> +				return -1;
> +			}
>  		}
>  	} else if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
>  		for (i = 0; i < num_bufs; i++) {
> @@ -893,106 +911,296 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  			    big_data ? buf_pool : ts_params-
> >large_mbuf_pool,
>  			    big_data ? 0 : MAX_SEGS,
>  			    big_data ? MAX_DATA_MBUF_SIZE :
> SMALL_SEG_SIZE) < 0)
> -				goto exit;
> +				return -1;
>  		}
>  	} 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);
>  			if (buf_ptr == NULL) {
>  				RTE_LOG(ERR, USER1,
>  					"Append extra bytes to the source
> mbuf failed\n");
> -				goto exit;
> +				return -1;
>  			}
>  			strlcpy(buf_ptr, test_bufs[i], data_size);
>  		}
>  	}
> 
> -	/* Prepare the destination mbufs */
> -	ret = rte_pktmbuf_alloc_bulk(buf_pool, comp_bufs, num_bufs);
> +	return 0;
> +}
> +
> +/**
> + * Data size calculation (for both compression and decompression).
> + *
> + * Developer is requested to provide input params
> + * according to the following rule:
> + *      if ops_processed == NULL -> compression
> + *      if ops_processed != NULL -> decompression
> + * Values bigger than 0 have to be returned to avoid problems
> + * with memory allocation
> + *
> + * @param ops_processed
> + *   Operations created as a result of compression phase. Should be
> + *   set to NULL for compression
> + * @param out_of_space_and_zlib
> + *   Boolean value to switch into "out of space" buffer if set.
> + *   To test "out-of-space" data size, zlib_decompress must be set as well.
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param i
> + *   current buffer index
> + * @return
> + *   - values bigger than 0
> + */
> +static inline uint32_t
> +test_mbufs_calculate_data_size(
> +		struct rte_comp_op *ops_processed[], /*can be equal to
> NULL*/
> +		unsigned int out_of_space_and_zlib,
> +		const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data,
> +		unsigned int i)
> +{
> +	/* local variables: */
> +	uint32_t data_size = 0;
> +	struct priv_op_data *priv_data;
> +	float ratio;
> +	uint8_t not_zlib_compr; /* true if zlib isn't current compression dev
> */
> +	enum overflow_test overflow = test_data->overflow;
> +
> +	/* from int_data: */
> +	const char * const *test_bufs = int_data->test_bufs;
> +
> +	if (out_of_space_and_zlib)
> +		data_size = OUT_OF_SPACE_BUF;
> +	else {
> +		if (ops_processed == NULL) {
> +
> +			not_zlib_compr = (test_data->zlib_dir ==
> ZLIB_DECOMPRESS
> +				|| test_data->zlib_dir == ZLIB_NONE);
> +
> +			ratio = (not_zlib_compr &&
> +				(overflow == OVERFLOW_ENABLED)) ?
> +				COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
> +				COMPRESS_BUF_SIZE_RATIO;
> +
> +			data_size = strlen(test_bufs[i]) * ratio;
> +
> +		} else {
> +			priv_data = (struct priv_op_data *)
> +					(ops_processed[i] + 1);
> +			data_size = strlen(test_bufs[priv_data->orig_idx]) +
> 1;
> +		}
> +	}
> +
> +	return data_size;
> +}
> +
> +
> +/**
> + * Memory buffers preparation (for both compression and decompression).
> + *
> + * Memory allocation for comp/decomp buffers from mempool, depending
> on
> + * ops_processed value. Developer is requested to provide input params
> + * according to the following rule:
> + *      if ops_processed == NULL -> current_bufs = comp_bufs[]
> + *      if ops_processed != NULL -> current_bufs = decomp_bufs[]
> + * -1 returned if function fail, without modifying the mbuf.
> + *
> + * @param ops_processed
> + *   Operations created as a result of compression phase. Should be
> + *   set to NULL for compression
> + * @param current_bufs
> + *   mbufs being prepared in the function.
> + * @param out_of_space_and_zlib
> + *   Boolean value to switch into "out of space" buffer if set.
> + *   To test "out-of-space" data size, zlib_decompress must be set as well.
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param current_extbuf_info,
> + *   The structure containing all the information related to external mbufs
> + * @param current_memzone
> + *   memzone used by external buffers
> + * @return
> + *   - 0: On success.
> + *   - -1: On error.
> + */
> +static int
> +test_mbufs_destination_preparation(
> +		struct rte_comp_op *ops_processed[], /*can be equal to
> NULL*/
> +		struct rte_mbuf *current_bufs[],
> +		unsigned int out_of_space_and_zlib,
> +		const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data,
> +		struct rte_mbuf_ext_shared_info *current_extbuf_info,
> +		const struct rte_memzone *current_memzone) {
> +	/* local variables: */
> +	unsigned int i;
> +	uint32_t data_size;
> +	int ret;
> +	char *buf_ptr;
> +
> +	struct comp_testsuite_params *ts_params = &testsuite_params;
> +
> +	/* from int_data: */
> +	unsigned int num_bufs = int_data->num_bufs;
> +
> +	/* from test_data: */
> +	unsigned int buff_type = test_data->buff_type;
> +	unsigned int big_data = test_data->big_data;
> +
> +	struct rte_mempool *buf_pool;
> +
> +	if (big_data)
> +		buf_pool = ts_params->big_mbuf_pool;
> +	else if (buff_type == SGL_BOTH)
> +		buf_pool = ts_params->small_mbuf_pool;
> +	else
> +		buf_pool = ts_params->large_mbuf_pool;
> +
> +	/* the mbufs allocation*/
> +	ret = rte_pktmbuf_alloc_bulk(buf_pool, current_bufs, num_bufs);
>  	if (ret < 0) {
>  		RTE_LOG(ERR, USER1,
>  			"Destination mbufs could not be allocated "
>  			"from the mempool\n");
> -		goto exit;
> +		return -1;
>  	}
> 
>  	if (test_data->use_external_mbufs) {
> -		compbuf_info.free_cb = extbuf_free_callback;
> -		compbuf_info.fcb_opaque = NULL;
> -		rte_mbuf_ext_refcnt_set(&compbuf_info, 1);
> +		current_extbuf_info->free_cb = extbuf_free_callback;
> +		current_extbuf_info->fcb_opaque = NULL;
> +		rte_mbuf_ext_refcnt_set(current_extbuf_info, 1);
>  		for (i = 0; i < num_bufs; i++) {
> -			rte_pktmbuf_attach_extbuf(comp_bufs[i],
> -					test_data->compbuf_memzone-
> >addr,
> -					test_data->compbuf_memzone-
> >iova,
> -					test_data->compbuf_memzone-
> >len,
> -					&compbuf_info);
> -			rte_pktmbuf_append(comp_bufs[i],
> -					test_data->compbuf_memzone-
> >len);
> +			rte_pktmbuf_attach_extbuf(current_bufs[i],
> +					current_memzone->addr,
> +					current_memzone->iova,
> +					current_memzone->len,
> +					current_extbuf_info);
> +			rte_pktmbuf_append(current_bufs[i],
> +					current_memzone->len);
>  		}
> -	} else if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
> -		for (i = 0; i < num_bufs; i++) {
> -			if (out_of_space == 1 && oos_zlib_decompress)
> -				data_size = OUT_OF_SPACE_BUF;
> -			else
> -				(data_size = strlen(test_bufs[i]) *
> -					COMPRESS_BUF_SIZE_RATIO);
> -
> -			if (prepare_sgl_bufs(NULL, comp_bufs[i],
> -			      data_size,
> -			      big_data ? buf_pool : ts_params-
> >small_mbuf_pool,
> -			      big_data ? buf_pool : ts_params-
> >large_mbuf_pool,
> -			      big_data ? 0 : MAX_SEGS,
> -			      big_data ? MAX_DATA_MBUF_SIZE :
> SMALL_SEG_SIZE)
> -					< 0)
> -				goto exit;
> -		}
> -
>  	} else {
>  		for (i = 0; i < num_bufs; i++) {
> -			if (out_of_space == 1 && oos_zlib_decompress)
> -				data_size = OUT_OF_SPACE_BUF;
> -			else {
> -				float ratio =
> -				((test_data->zlib_dir == ZLIB_DECOMPRESS
> ||
> -				   test_data->zlib_dir == ZLIB_NONE) &&
> -				  overflow_tst == OVERFLOW_ENABLED) ?
> -
> COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
> -					 COMPRESS_BUF_SIZE_RATIO;
> -
> -				data_size = strlen(test_bufs[i]) * ratio;
> -			}
> -			buf_ptr = rte_pktmbuf_append(comp_bufs[i],
> data_size);
> -			if (buf_ptr == NULL) {
> -				RTE_LOG(ERR, USER1,
> -					"Append extra bytes to the
> destination mbuf failed\n");
> -				goto exit;
> +
> +			/* data size calculation */
> +			data_size = test_mbufs_calculate_data_size(
> +					ops_processed,
> +					out_of_space_and_zlib,
> +					int_data,
> +					test_data,
> +					i);
> +
> +			/* data allocation */
> +			if (buff_type == SGL_BOTH || buff_type ==
> LB_TO_SGL) {
> +				ret = prepare_sgl_bufs(NULL,
> current_bufs[i],
> +				      data_size,
> +				      big_data ? buf_pool :
> +						ts_params-
> >small_mbuf_pool,
> +				      big_data ? buf_pool :
> +						ts_params-
> >large_mbuf_pool,
> +				      big_data ? 0 : MAX_SEGS,
> +				      big_data ? MAX_DATA_MBUF_SIZE :
> +						 SMALL_SEG_SIZE);
> +				if (ret < 0)
> +					return -1;
> +			} else {
> +				buf_ptr =
> rte_pktmbuf_append(current_bufs[i],
> +						data_size);
> +				if (buf_ptr == NULL) {
> +					RTE_LOG(ERR, USER1,
> +						"Append extra bytes to the
> destination mbuf failed\n");
> +					return -1;
> +				}
>  			}
>  		}
>  	}
> 
> +	return 0;
> +}
> +
> +/**
> + * The main compression function.
> + *
> + * Operation(s) configuration, depending on CLI parameters.
> + * Operation(s) processing.
> + * -1 returned if function fail.
> + *
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param priv_arrays
> + *   A container used for aggregation all the private test arrays.
> + * @return
> + *   - 0: On success.
> + *   - -1: On error.
> + */
> +static int
> +test_deflate_comp_run(const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data,
> +		const struct test_private_arrays *priv_arrays) {
> +	/* local variables: */
> +	struct priv_op_data *priv_data;
> +	unsigned int i;
> +	uint16_t num_priv_xforms = 0;
> +	int ret;
> +	int ret_status = 0;
> +	char *buf_ptr;
> +
> +	struct comp_testsuite_params *ts_params = &testsuite_params;
> +
> +	/* from test_data: */
> +	enum rte_comp_op_type operation_type = test_data-
> >compress_state;
> +	unsigned int zlib_compress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_COMPRESS);
> +
> +	/* from int_data: */
> +	struct rte_comp_xform **compress_xforms = int_data-
> >compress_xforms;
> +	unsigned int num_xforms = int_data->num_xforms;
> +	unsigned int num_bufs = int_data->num_bufs;
> +
> +	/* from priv_arrays: */
> +	struct rte_mbuf **comp_bufs = priv_arrays->comp_bufs;
> +	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
> +	struct rte_comp_op **ops = priv_arrays->ops;
> +	struct rte_comp_op **ops_processed = priv_arrays-
> >ops_processed;
> +	void **priv_xforms = priv_arrays->priv_xforms;
> +
> +	const struct rte_compressdev_capabilities *capa =
> +		rte_compressdev_capability_get(0,
> RTE_COMP_ALGO_DEFLATE);
> +
>  	/* Build the compression operations */
>  	ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops,
> num_bufs);
>  	if (ret < 0) {
>  		RTE_LOG(ERR, USER1,
>  			"Compress operations could not be allocated "
>  			"from the mempool\n");
> +		ret_status = -1;
>  		goto exit;
>  	}
> 
> -
>  	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;
> -		if (compress_state == RTE_COMP_OP_STATELESS)
> +
> +		if (operation_type == RTE_COMP_OP_STATELESS) {
>  			ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
> -		else {
> +		} else {
>  			RTE_LOG(ERR, USER1,
> -				"Stateful operations are not supported "
> -				"in these tests yet\n");
> +				"Compression: stateful operations are not "
> +				"supported in these tests yet\n");
> +			ret_status = -1;
>  			goto exit;
>  		}
>  		ops[i]->input_chksum = 0;
> @@ -1007,14 +1215,16 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  	}
> 
>  	/* Compress data (either with Zlib API or compressdev API */
> -	if (zlib_dir == ZLIB_COMPRESS || zlib_dir == ZLIB_ALL) {
> +	if (zlib_compress) {
>  		for (i = 0; i < num_bufs; i++) {
>  			const struct rte_comp_xform *compress_xform =
>  				compress_xforms[i % num_xforms];
>  			ret = compress_zlib(ops[i], compress_xform,
>  					DEFAULT_MEM_LEVEL);
> -			if (ret < 0)
> +			if (ret < 0) {
> +				ret_status = -1;
>  				goto exit;
> +			}
> 
>  			ops_processed[i] = ops[i];
>  		}
> @@ -1022,24 +1232,26 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  		/* Create compress private xform data */
>  		for (i = 0; i < num_xforms; i++) {
>  			ret = rte_compressdev_private_xform_create(0,
> -				(const struct rte_comp_xform
> *)compress_xforms[i],
> +				(const struct rte_comp_xform *)
> +					compress_xforms[i],
>  				&priv_xforms[i]);
>  			if (ret < 0) {
>  				RTE_LOG(ERR, USER1,
>  					"Compression private xform "
>  					"could not be created\n");
> +				ret_status = -1;
>  				goto exit;
>  			}
>  			num_priv_xforms++;
>  		}
> -
>  		if (capa->comp_feature_flags &
>  				RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
>  			/* Attach shareable private xform data to ops */
>  			for (i = 0; i < num_bufs; i++)
> -				ops[i]->private_xform = priv_xforms[i %
> num_xforms];
> +				ops[i]->private_xform =
> +						priv_xforms[i %
> num_xforms];
>  		} else {
> -			/* Create rest of the private xforms for the other ops
> */
> +		/* Create rest of the private xforms for the other ops */
>  			for (i = num_xforms; i < num_bufs; i++) {
>  				ret =
> rte_compressdev_private_xform_create(0,
>  					compress_xforms[i % num_xforms],
> @@ -1048,26 +1260,28 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  					RTE_LOG(ERR, USER1,
>  						"Compression private xform "
>  						"could not be created\n");
> +					ret_status = -1;
>  					goto exit;
>  				}
>  				num_priv_xforms++;
>  			}
> -
>  			/* Attach non shareable private xform data to ops */
>  			for (i = 0; i < num_bufs; i++)
>  				ops[i]->private_xform = priv_xforms[i];
>  		}
> 
>  recovery_lb:
> -		ret = test_run_enqueue_dequeue(ops, num_bufs,
> ops_processed);
> +		ret = test_run_enqueue_dequeue(ops, ops_processed,
> num_bufs);
>  		if (ret < 0) {
>  			RTE_LOG(ERR, USER1,
> -				"Enqueue/dequeue operation failed\n");
> +				"Compression: enqueue/dequeue operation
> failed\n");
> +			ret_status = -1;
>  			goto exit;
>  		}
> 
>  		for (i = 0; i < num_bufs; i++) {
> -			compressed_data_size[i] += ops_processed[i]-
> >produced;
> +			priv_arrays->compressed_data_size[i] +=
> +					ops_processed[i]->produced;
> 
>  			if (ops_processed[i]->status ==
> 
> 	RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE) { @@ -
> 1088,21 +1302,83 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  				if (buf_ptr == NULL) {
>  					RTE_LOG(ERR, USER1,
>  						"Data recovery: append extra
> bytes to the current mbuf failed\n");
> +					ret_status = -1;
>  					goto exit;
>  				}
>  				goto recovery_lb;
>  			}
>  		}
> -		deqd_retries = 0;
> +	}
> +
> +exit:
> +	/* Free resources */
> +	if (ret_status < 0)
> +		for (i = 0; i < num_bufs; i++) {
> +			rte_comp_op_free(ops[i]);
> +			ops_processed[i] = NULL;
> +		}
> 
> -		/* Free compress private xforms */
> -		for (i = 0; i < num_priv_xforms; i++) {
> +	/* Free compress private xforms */
> +	for (i = 0; i < num_priv_xforms; i++) {
> +		if (priv_xforms[i] != NULL) {
>  			rte_compressdev_private_xform_free(0,
> priv_xforms[i]);
>  			priv_xforms[i] = NULL;
>  		}
> -		num_priv_xforms = 0;
>  	}
> 
> +	return ret_status;
> +}
> +
> +/**
> + * Prints out the test report. Memory freeing.
> + *
> + * Called after successful compression.
> + * Operation(s) status validation and decompression buffers freeing.
> +
> + * -1 returned if function fail.
> + *
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param priv_arrays
> + *   A container used for aggregation all the private test arrays.
> + * @return
> + *   - 2: Some operation is not supported
> + *   - 1: Decompression should be skipped
> + *   - 0: On success.
> + *   - -1: On error.
> + */
> +static int
> +test_deflate_comp_finalize(const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data,
> +		const struct test_private_arrays *priv_arrays) {
> +	/* local variables: */
> +	unsigned int i;
> +	struct priv_op_data *priv_data;
> +
> +	/* from int_data: */
> +	unsigned int num_xforms = int_data->num_xforms;
> +	struct rte_comp_xform **compress_xforms = int_data-
> >compress_xforms;
> +	uint16_t *buf_idx = int_data->buf_idx;
> +	unsigned int num_bufs = int_data->num_bufs;
> +
> +	/* from priv_arrays: */
> +	struct rte_comp_op **ops_processed = priv_arrays-
> >ops_processed;
> +	uint64_t *compress_checksum = priv_arrays->compress_checksum;
> +	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
> +	struct rte_comp_op **ops = priv_arrays->ops;
> +
> +	/* from test_data: */
> +	unsigned int out_of_space = test_data->out_of_space;
> +	unsigned int zlib_compress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_COMPRESS);
> +	unsigned int zlib_decompress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_DECOMPRESS);
> +
>  	for (i = 0; i < num_bufs; i++) {
>  		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
>  		uint16_t xform_idx = priv_data->orig_idx % num_xforms;
> @@ -1111,7 +1387,7 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  		enum rte_comp_huffman huffman_type =
>  			compress_xform->deflate.huffman;
>  		char engine[] = "zlib (directly, not PMD)";
> -		if (zlib_dir != ZLIB_COMPRESS && zlib_dir != ZLIB_ALL)
> +		if (zlib_decompress)
>  			strlcpy(engine, "PMD", sizeof(engine));
> 
>  		RTE_LOG(DEBUG, USER1, "Buffer %u compressed by %s from
> %u to"
> @@ -1134,116 +1410,103 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  	 * compress operation information is needed for the decompression
> stage)
>  	 */
>  	for (i = 0; i < num_bufs; i++) {
> -		if (out_of_space && oos_zlib_decompress) {
> +		if (out_of_space && !zlib_compress) {
>  			if (ops_processed[i]->status !=
> 
> 	RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
> -				ret_status = TEST_FAILED;
>  				RTE_LOG(ERR, USER1,
>  					"Operation without expected out of "
>  					"space status error\n");
> -				goto exit;
> +				return -1;
>  			} else
>  				continue;
>  		}
> 
>  		if (ops_processed[i]->status !=
> RTE_COMP_OP_STATUS_SUCCESS) {
> -			if (overflow_tst == OVERFLOW_ENABLED) {
> +			if (test_data->overflow == OVERFLOW_ENABLED) {
>  				if (ops_processed[i]->status ==
> 
> 	RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
> -					ret_status = 1;
>  					RTE_LOG(INFO, USER1,
>  					"Out-of-space-recoverable
> functionality"
>  					" is not supported on this device\n");
> -					goto exit;
> +					return 2;
>  				}
>  			}
> +
>  			RTE_LOG(ERR, USER1,
>  				"Some operations were not successful\n");
> -			goto exit;
> +			return -1;
>  		}
>  		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
>  		rte_pktmbuf_free(uncomp_bufs[priv_data->orig_idx]);
>  		uncomp_bufs[priv_data->orig_idx] = NULL;
>  	}
> 
> -	if (out_of_space && oos_zlib_decompress) {
> -		ret_status = TEST_SUCCESS;
> -		goto exit;
> -	}
> +	if (out_of_space && !zlib_compress)
> +		return 1;
> 
> -	/* Allocate buffers for decompressed data */
> -	ret = rte_pktmbuf_alloc_bulk(buf_pool, uncomp_bufs, num_bufs);
> -	if (ret < 0) {
> -		RTE_LOG(ERR, USER1,
> -			"Destination mbufs could not be allocated "
> -			"from the mempool\n");
> -		goto exit;
> -	}
> +	return 0;
> +}
> 
> -	if (test_data->use_external_mbufs) {
> -		decompbuf_info.free_cb = extbuf_free_callback;
> -		decompbuf_info.fcb_opaque = NULL;
> -		rte_mbuf_ext_refcnt_set(&decompbuf_info, 1);
> -		for (i = 0; i < num_bufs; i++) {
> -			rte_pktmbuf_attach_extbuf(uncomp_bufs[i],
> -					test_data->uncompbuf_memzone-
> >addr,
> -					test_data->uncompbuf_memzone-
> >iova,
> -					test_data->uncompbuf_memzone-
> >len,
> -					&decompbuf_info);
> -			rte_pktmbuf_append(uncomp_bufs[i],
> -					test_data->uncompbuf_memzone-
> >len);
> -		}
> -	} else if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
> -		for (i = 0; i < num_bufs; i++) {
> -			priv_data = (struct priv_op_data *)
> -					(ops_processed[i] + 1);
> -			if (out_of_space == 1 && oos_zlib_compress)
> -				data_size = OUT_OF_SPACE_BUF;
> -			else if (test_data->decompress_output_block_size
> != 0)
> -				data_size =
> -					test_data-
> >decompress_output_block_size;
> -			else
> -				data_size =
> -				strlen(test_bufs[priv_data->orig_idx]) + 1;
> -
> -			if (prepare_sgl_bufs(NULL, uncomp_bufs[i],
> -			       data_size,
> -			       big_data ? buf_pool : ts_params-
> >small_mbuf_pool,
> -			       big_data ? buf_pool : ts_params-
> >large_mbuf_pool,
> -			       big_data ? 0 : MAX_SEGS,
> -			       big_data ? MAX_DATA_MBUF_SIZE :
> SMALL_SEG_SIZE)
> -					< 0)
> -				goto exit;
> -		}
> +/**
> + * The main decompression function.
> + *
> + * Operation(s) configuration, depending on CLI parameters.
> + * Operation(s) processing.
> + * -1 returned if function fail.
> + *
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param priv_arrays
> + *   A container used for aggregation all the private test arrays.
> + * @return
> + *   - 0: On success.
> + *   - -1: On error.
> + */
> +static int
> +test_deflate_decomp_run(const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data,
> +		struct test_private_arrays *priv_arrays) {
> 
> -	} else {
> -		for (i = 0; i < num_bufs; i++) {
> -			priv_data = (struct priv_op_data *)
> -					(ops_processed[i] + 1);
> -			if (out_of_space == 1 && oos_zlib_compress)
> -				data_size = OUT_OF_SPACE_BUF;
> -			else if (test_data->decompress_output_block_size
> != 0)
> -				data_size =
> -					test_data-
> >decompress_output_block_size;
> -			else
> -				data_size =
> -				strlen(test_bufs[priv_data->orig_idx]) + 1;
> +	/* local variables: */
> +	struct priv_op_data *priv_data;
> +	unsigned int i;
> +	uint16_t num_priv_xforms = 0;
> +	int ret;
> +	int ret_status = 0;
> 
> -			buf_ptr = rte_pktmbuf_append(uncomp_bufs[i],
> data_size);
> -			if (buf_ptr == NULL) {
> -				RTE_LOG(ERR, USER1,
> -					"Append extra bytes to the
> decompressed mbuf failed\n");
> -				goto exit;
> -			}
> -		}
> -	}
> +	struct comp_testsuite_params *ts_params = &testsuite_params;
> +
> +	/* from test_data: */
> +	enum rte_comp_op_type operation_type = test_data-
> >decompress_state;
> +	unsigned int zlib_decompress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_DECOMPRESS);
> +
> +	/* from int_data: */
> +	struct rte_comp_xform **decompress_xforms = int_data-
> >decompress_xforms;
> +	unsigned int num_xforms = int_data->num_xforms;
> +	unsigned int num_bufs = int_data->num_bufs;
> +
> +	/* from priv_arrays: */
> +	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
> +	struct rte_comp_op **ops = priv_arrays->ops;
> +	struct rte_comp_op **ops_processed = priv_arrays-
> >ops_processed;
> +	void **priv_xforms = priv_arrays->priv_xforms;
> +	uint32_t *compressed_data_size = priv_arrays-
> >compressed_data_size;
> +	void **stream = priv_arrays->stream;
> +
> +	const struct rte_compressdev_capabilities *capa =
> +		rte_compressdev_capability_get(0,
> RTE_COMP_ALGO_DEFLATE);
> 
> -	/* Build the decompression operations */
>  	ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops,
> num_bufs);
>  	if (ret < 0) {
>  		RTE_LOG(ERR, USER1,
>  			"Decompress operations could not be allocated "
>  			"from the mempool\n");
> +		ret_status = -1;
>  		goto exit;
>  	}
> 
> @@ -1256,22 +1519,25 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  		 * Set the length of the compressed data to the
>  		 * number of bytes that were produced in the previous stage
>  		 */
> +
>  		if (compressed_data_size[i])
>  			ops[i]->src.length = compressed_data_size[i];
>  		else
>  			ops[i]->src.length = ops_processed[i]->produced;
> 
>  		ops[i]->dst.offset = 0;
> -		if (decompress_state == RTE_COMP_OP_STATELESS) {
> +
> +		if (operation_type == RTE_COMP_OP_STATELESS) {
>  			ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
>  			ops[i]->op_type = RTE_COMP_OP_STATELESS;
> -		} else if (zlib_dir == ZLIB_COMPRESS || zlib_dir ==
> ZLIB_NONE) {
> +		} else if (!zlib_decompress) {
>  			ops[i]->flush_flag = RTE_COMP_FLUSH_SYNC;
>  			ops[i]->op_type = RTE_COMP_OP_STATEFUL;
>  		} else {
>  			RTE_LOG(ERR, USER1,
> -				"Stateful operations are not supported "
> -				"in these tests yet\n");
> +				"Decompression: stateful operations are"
> +				" not supported in these tests yet\n");
> +			ret_status = -1;
>  			goto exit;
>  		}
>  		ops[i]->input_chksum = 0;
> @@ -1290,7 +1556,7 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  	rte_comp_op_bulk_free(ops_processed, num_bufs);
> 
>  	/* Decompress data (either with Zlib API or compressdev API */
> -	if (zlib_dir == ZLIB_DECOMPRESS || zlib_dir == ZLIB_ALL) {
> +	if (zlib_decompress) {
>  		for (i = 0; i < num_bufs; i++) {
>  			priv_data = (struct priv_op_data *)(ops[i] + 1);
>  			uint16_t xform_idx = priv_data->orig_idx %
> num_xforms; @@ -1298,13 +1564,15 @@ test_deflate_comp_decomp(const
> struct interim_data_params *int_data,
>  				decompress_xforms[xform_idx];
> 
>  			ret = decompress_zlib(ops[i], decompress_xform);
> -			if (ret < 0)
> +			if (ret < 0) {
> +				ret_status = -1;
>  				goto exit;
> +			}
> 
>  			ops_processed[i] = ops[i];
>  		}
>  	} else {
> -		if (decompress_state == RTE_COMP_OP_STATELESS) {
> +		if (operation_type == RTE_COMP_OP_STATELESS) {
>  			/* Create decompress private xform data */
>  			for (i = 0; i < num_xforms; i++) {
>  				ret =
> rte_compressdev_private_xform_create(0,
> @@ -1315,6 +1583,7 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  					RTE_LOG(ERR, USER1,
>  						"Decompression private
> xform "
>  						"could not be created\n");
> +					ret_status = -1;
>  					goto exit;
>  				}
>  				num_priv_xforms++;
> @@ -1341,7 +1610,9 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  					      &priv_xforms[i]);
>  					if (ret < 0) {
>  						RTE_LOG(ERR, USER1,
> -							"Decompression
> private xform could not be created\n");
> +							"Decompression
> private xform"
> +							" could not be
> created\n");
> +						ret_status = -1;
>  						goto exit;
>  					}
>  					num_priv_xforms++;
> @@ -1361,59 +1632,86 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  		} else {
>  			/* Create a stream object for stateful decompression
> */
>  			ret = rte_compressdev_stream_create(0,
> -					decompress_xforms[0], &stream);
> +					decompress_xforms[0], stream);
>  			if (ret < 0) {
>  				RTE_LOG(ERR, USER1,
>  					"Decompression stream could not be
> created, error %d\n",
>  					ret);
> +				ret_status = -1;
>  				goto exit;
>  			}
>  			/* Attach stream to ops */
>  			for (i = 0; i < num_bufs; i++)
> -				ops[i]->stream = stream;
> +				ops[i]->stream = *stream;
>  		}
> 
> -next_step:
> -		/* Enqueue and dequeue all operations */
> -		num_enqd = rte_compressdev_enqueue_burst(0, 0, ops,
> num_bufs);
> -		if (num_enqd < num_bufs) {
> -			RTE_LOG(ERR, USER1,
> -				"The operations could not be enqueued\n");
> -			goto exit;
> -		}
> +		priv_arrays->num_priv_xforms = num_priv_xforms;
> +	}
> 
> -		num_total_deqd = 0;
> -		do {
> -			/*
> -			 * If retrying a dequeue call, wait for 10 ms to allow
> -			 * enough time to the driver to process the
> operations
> -			 */
> -			if (deqd_retries != 0) {
> -				/*
> -				 * Avoid infinite loop if not all the
> -				 * operations get out of the device
> -				 */
> -				if (deqd_retries == MAX_DEQD_RETRIES) {
> -					RTE_LOG(ERR, USER1,
> -						"Not all operations could be "
> -						"dequeued\n");
> -					goto exit;
> -				}
> -				usleep(DEQUEUE_WAIT_TIME);
> -			}
> -			num_deqd = rte_compressdev_dequeue_burst(0, 0,
> -					&ops_processed[num_total_deqd],
> num_bufs);
> -			num_total_deqd += num_deqd;
> -			deqd_retries++;
> -		} while (num_total_deqd < num_enqd);
> +exit:
> +	return ret_status;
> +}
> 
> -		deqd_retries = 0;
> -	}
> +/**
> + * Prints out the test report. Memory freeing.
> + *
> + * Called after successful decompression.
> + * Operation(s) status validation and compression buffers freeing.
> +
> + * -1 returned if function fail.
> + *
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param priv_arrays
> + *   A container used for aggregation all the private test arrays.
> + * @return
> + *   - 2: Next step must be executed by the caller (stateful decompression
> only)
> + *   - 1: On success (caller should stop and exit)
> + *   - 0: On success.
> + *   - -1: On error.
> + */
> +static int
> +test_deflate_decomp_finalize(const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data,
> +		const struct test_private_arrays *priv_arrays) {
> +	/* local variables: */
> +	unsigned int i;
> +	struct priv_op_data *priv_data;
> +	static unsigned int step;
> +
> +	/* from int_data: */
> +	uint16_t *buf_idx = int_data->buf_idx;
> +	unsigned int num_bufs = int_data->num_bufs;
> +	const char * const *test_bufs = int_data->test_bufs;
> +	struct rte_comp_xform **compress_xforms = int_data-
> >compress_xforms;
> +
> +	/* from priv_arrays: */
> +	struct rte_comp_op **ops_processed = priv_arrays-
> >ops_processed;
> +	struct rte_mbuf **comp_bufs = priv_arrays->comp_bufs;
> +	struct rte_comp_op **ops = priv_arrays->ops;
> +	uint64_t *compress_checksum = priv_arrays->compress_checksum;
> +	unsigned int *decomp_produced_data_size =
> +			priv_arrays->decomp_produced_data_size;
> +	char **all_decomp_data = priv_arrays->all_decomp_data;
> +
> +	/* from test_data: */
> +	unsigned int out_of_space = test_data->out_of_space;
> +	enum rte_comp_op_type operation_type = test_data-
> >decompress_state;
> +
> +	unsigned int zlib_compress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_COMPRESS);
> +	unsigned int zlib_decompress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_DECOMPRESS);
> 
>  	for (i = 0; i < num_bufs; i++) {
>  		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
>  		char engine[] = "zlib, (directly, no PMD)";
> -		if (zlib_dir != ZLIB_DECOMPRESS && zlib_dir != ZLIB_ALL)
> +		if (zlib_compress)
>  			strlcpy(engine, "pmd", sizeof(engine));
>  		RTE_LOG(DEBUG, USER1,
>  			"Buffer %u decompressed by %s from %u to %u
> bytes\n", @@ -1427,19 +1725,19 @@ test_deflate_comp_decomp(const
> struct interim_data_params *int_data,
>  	 * compress operation information is still needed)
>  	 */
>  	for (i = 0; i < num_bufs; i++) {
> -		if (out_of_space && oos_zlib_compress) {
> +		if (out_of_space && !zlib_decompress) {
>  			if (ops_processed[i]->status !=
> -
> 	RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
> -				ret_status = TEST_FAILED;
> +
> 	RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
> +
>  				RTE_LOG(ERR, USER1,
>  					"Operation without expected out of "
>  					"space status error\n");
> -				goto exit;
> +				return -1;
>  			} else
>  				continue;
>  		}
> 
> -		if (decompress_state == RTE_COMP_OP_STATEFUL
> +		if (operation_type == RTE_COMP_OP_STATEFUL
>  			&& (ops_processed[i]->status ==
> 
> 	RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE
>  			    || ops_processed[i]->status ==
> @@ -1449,28 +1747,29 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  					ops_processed[i]->m_dst,
>  					ops_processed[i]->dst.offset,
>  					ops_processed[i]->produced,
> -					all_decomp_data +
> -
> 	decomp_produced_data_size);
> -			if (ptr != all_decomp_data +
> decomp_produced_data_size)
> -				rte_memcpy(all_decomp_data +
> -					   decomp_produced_data_size,
> +					*all_decomp_data +
> +
> 	*decomp_produced_data_size);
> +			if (ptr != *all_decomp_data +
> +					*decomp_produced_data_size)
> +				rte_memcpy(*all_decomp_data +
> +					   *decomp_produced_data_size,
>  					   ptr, ops_processed[i]->produced);
> -			decomp_produced_data_size += ops_processed[i]-
> >produced;
> +
> +			*decomp_produced_data_size +=
> +					ops_processed[i]->produced;
>  			if (ops_processed[i]->src.length >
>  					ops_processed[i]->consumed) {
>  				if (ops_processed[i]->status ==
> 
> 	RTE_COMP_OP_STATUS_SUCCESS) {
> -					ret_status = -1;
>  					RTE_LOG(ERR, USER1,
>  					      "Operation finished too early\n");
> -					goto exit;
> +					return -1;
>  				}
>  				step++;
>  				if (step >= test_data-
> >decompress_steps_max) {
> -					ret_status = -1;
>  					RTE_LOG(ERR, USER1,
>  					  "Operation exceeded maximum
> steps\n");
> -					goto exit;
> +					return -1;
>  				}
>  				ops[i] = ops_processed[i];
>  				ops[i]->status =
> @@ -1479,7 +1778,9 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  						ops_processed[i]-
> >consumed;
>  				ops[i]->src.length -=
>  						ops_processed[i]-
> >consumed;
> -				goto next_step;
> +				/* repeat the operation */
> +				//goto next_step;
> +				return 2;
>  			} else {
>  				/* Compare the original stream with the */
>  				/* decompressed stream (in size and the
> data) */ @@ -1487,22 +1788,22 @@ test_deflate_comp_decomp(const
> struct interim_data_params *int_data,
>  						(ops_processed[i] + 1);
>  				const char *buf1 =
>  						test_bufs[priv_data-
> >orig_idx];
> -				const char *buf2 = all_decomp_data;
> +				const char *buf2 = *all_decomp_data;
> 
>  				if (compare_buffers(buf1, strlen(buf1) + 1,
> -					  buf2, decomp_produced_data_size)
> < 0)
> -					goto exit;
> +					  buf2,
> *decomp_produced_data_size) < 0)
> +					return -1;
>  				/* 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],
> +			"The checksums differ\n"
> +			"Compression Checksum: %" PRIu64
> "\tDecompression "
> +			"Checksum: %" PRIu64 "\n", compress_checksum[i],
>  					       ops_processed[i]-
> >output_chksum);
> -						goto exit;
> +						return -1;
>  					}
>  				}
>  			}
> @@ -1510,18 +1811,58 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  			   RTE_COMP_OP_STATUS_SUCCESS) {
>  			RTE_LOG(ERR, USER1,
>  				"Some operations were not successful\n");
> -			goto exit;
> +			return -1;
>  		}
>  		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
>  		rte_pktmbuf_free(comp_bufs[priv_data->orig_idx]);
>  		comp_bufs[priv_data->orig_idx] = NULL;
>  	}
> 
> -	if ((out_of_space && oos_zlib_compress)
> -			|| (decompress_state ==
> RTE_COMP_OP_STATEFUL)) {
> -		ret_status = TEST_SUCCESS;
> -		goto exit;
> -	}
> +	if (out_of_space && !zlib_decompress)
> +		return 1;
> +
> +	return 0;
> +}
> +
> +/**
> + * Validation of the output (compression/decompression) data.
> + *
> + * The function compares the source stream with the output stream,
> + * after decompression, to check if compression/decompression
> + * was correct.
> + * -1 returned if function fail.
> + *
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param priv_arrays
> + *   A container used for aggregation all the private test arrays.
> + * @return
> + *   - 0: On success.
> + *   - -1: On error.
> + */
> +static int
> +test_results_validation(const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data,
> +		const struct test_private_arrays *priv_arrays) {
> +	/* local variables: */
> +	unsigned int i;
> +	struct priv_op_data *priv_data;
> +	const char *buf1;
> +	const char *buf2;
> +	char *contig_buf = NULL;
> +	uint32_t data_size;
> +
> +	/* from int_data: */
> +	struct rte_comp_xform **compress_xforms = int_data-
> >compress_xforms;
> +	unsigned int num_bufs = int_data->num_bufs;
> +	const char * const *test_bufs = int_data->test_bufs;
> +
> +	/* from priv_arrays: */
> +	uint64_t *compress_checksum = priv_arrays->compress_checksum;
> +	struct rte_comp_op **ops_processed = priv_arrays-
> >ops_processed;
> 
>  	/*
>  	 * Compare the original stream with the decompressed stream @@ -
> 1529,13 +1870,13 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  	 */
>  	for (i = 0; i < num_bufs; i++) {
>  		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
> -		const char *buf1 = test_data->use_external_mbufs ?
> +		buf1 = test_data->use_external_mbufs ?
>  				test_data->inbuf_memzone->addr :
>  				test_bufs[priv_data->orig_idx];
> -		const char *buf2;
>  		data_size = test_data->use_external_mbufs ?
>  				test_data->inbuf_data_size :
>  				strlen(buf1) + 1;
> +
>  		contig_buf = rte_malloc(NULL, ops_processed[i]->produced,
> 0);
>  		if (contig_buf == NULL) {
>  			RTE_LOG(ERR, USER1, "Contiguous buffer could not "
> @@ -1565,24 +1906,207 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  		rte_free(contig_buf);
>  		contig_buf = NULL;
>  	}
> +	return 0;
> +
> +exit:
> +	rte_free(contig_buf);
> +	return -1;
> +}
> +
> +/**
> + * Compresses and decompresses input stream with compressdev API and
> +Zlib API
> + *
> + * Basic test function. Common for all the functional tests.
> + * -1 returned if function fail.
> + *
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @return
> + *   - 1: Some operation not supported
> + *   - 0: On success.
> + *   - -1: On error.
> + */
> +
> +static int
> +test_deflate_comp_decomp(const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data) {
> +	unsigned int num_bufs = int_data->num_bufs;
> +	unsigned int out_of_space = test_data->out_of_space;
> +
> +	void *stream = NULL;
> +	char *all_decomp_data = NULL;
> +	unsigned int decomp_produced_data_size = 0;
> +
> +	int ret_status = -1;
> +	int ret;
> +	struct rte_mbuf *uncomp_bufs[num_bufs];
> +	struct rte_mbuf *comp_bufs[num_bufs];
> +	struct rte_comp_op *ops[num_bufs];
> +	struct rte_comp_op *ops_processed[num_bufs];
> +	void *priv_xforms[num_bufs];
> +	unsigned int i;
> +
> +	uint64_t compress_checksum[num_bufs];
> +	uint32_t compressed_data_size[num_bufs];
> +	char *contig_buf = NULL;
> +
> +	struct rte_mbuf_ext_shared_info compbuf_info;
> +	struct rte_mbuf_ext_shared_info decompbuf_info;
> +
> +	const struct rte_compressdev_capabilities *capa;
> +
> +	/* Compressing with CompressDev */
> +	unsigned int zlib_compress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_COMPRESS);
> +	unsigned int zlib_decompress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_DECOMPRESS);
> +
> +	struct test_private_arrays priv_arrays;
> +
> +	priv_arrays.uncomp_bufs = uncomp_bufs;
> +	priv_arrays.comp_bufs = comp_bufs;
> +	priv_arrays.ops = ops;
> +	priv_arrays.ops_processed = ops_processed;
> +	priv_arrays.priv_xforms = priv_xforms;
> +	priv_arrays.compress_checksum = compress_checksum;
> +	priv_arrays.compressed_data_size = compressed_data_size;
> +
> +	priv_arrays.stream = &stream;
> +	priv_arrays.all_decomp_data = &all_decomp_data;
> +	priv_arrays.decomp_produced_data_size =
> &decomp_produced_data_size;
> +
> +	priv_arrays.num_priv_xforms = 0; /* it's used for deompression only
> */
> +
> +	capa = rte_compressdev_capability_get(0,
> RTE_COMP_ALGO_DEFLATE);
> +	if (capa == NULL) {
> +		RTE_LOG(ERR, USER1,
> +			"Compress device does not support DEFLATE\n");
> +		return -1;
> +	}
> +	test_objects_init(&priv_arrays, num_bufs);
Do we need this? Why we just cant call source_prep API? That will also setup uncompressed_bufs
> +
> +	/* Prepare the source mbufs with the data */
> +	ret = test_mbufs_source_preparation(int_data, test_data,
> &priv_arrays);
For code readability sake, it could test_setup_uncom_bufs() 

> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	}
> +
> +/* COMPRESSION  */
> +
> +	/* Prepare the destination mbufs */
> +	ret = test_mbufs_destination_preparation(
Why we cant keep this prototype same as source_preparation() API for better readability?
I mean we can pass priv_arry here too...

> +			NULL, /*can be equal to NULL*/
> +			comp_bufs,
> +			out_of_space == 1 && !zlib_compress,
> +			int_data,
> +			test_data,
> +			&compbuf_info,
> +			test_data->compbuf_memzone);
> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	}
> +
> +	/* Run compression */
> +	ret = test_deflate_comp_run(int_data, test_data, &priv_arrays);
> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	}
> +
> +	ret = test_deflate_comp_finalize(int_data, test_data, &priv_arrays);
> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	} else if (ret == 1) {
> +		ret_status = 0;
> +		goto exit;
> +	} else if (ret == 2) {
> +		ret_status = 1;	 /* some operation not supported */
> +		goto exit;
> +	}
> +
> +/* DECOMPRESSION  */
> +
> +	/* Allocate buffers for decompressed data */
> +	ret = test_mbufs_destination_preparation(
> +			ops_processed, /*can be equal to NULL*/
> +			uncomp_bufs,
> +			out_of_space == 1 && !zlib_decompress,
> +			int_data,
> +			test_data,
> +			&decompbuf_info,
> +			test_data->uncompbuf_memzone);
> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	}
> +
> +	/* Run decompression */
> +	ret = test_deflate_decomp_run(int_data, test_data, &priv_arrays);
> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	}
> +
> +	if (!zlib_decompress) {
> +next_step:	/* next step for stateful decompression only */
> +		ret = test_run_enqueue_dequeue(ops, ops_processed,
> num_bufs);
> +		if (ret < 0) {
> +			ret_status = -1;
> +			RTE_LOG(ERR, USER1,
> +				"Decompression: enqueue/dequeue
> operation failed\n");
> +		}
> +	}
> 
> -	ret_status = TEST_SUCCESS;
> +	ret = test_deflate_decomp_finalize(int_data, test_data,
> &priv_arrays);
> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	} else if (ret == 1) {
> +		ret_status = 0;
> +		goto exit;
> +	} else if (ret == 2) {
> +		goto next_step;
> +	}
> +
> +/* FINAL PROCESSING  */
> +
> +	ret = test_results_validation(int_data, test_data, &priv_arrays);
> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	}
> +	ret_status = 0;
> 
>  exit:
>  	/* Free resources */
> +
> +	if (stream != NULL)
> +		rte_compressdev_stream_free(0, stream);
> +	if (all_decomp_data != NULL)
> +		rte_free(all_decomp_data);
> +
> +	/* Free compress private xforms */
> +	for (i = 0; i < priv_arrays.num_priv_xforms; i++) {
> +		if (priv_xforms[i] != NULL) {
> +			rte_compressdev_private_xform_free(0,
> priv_xforms[i]);
> +			priv_xforms[i] = NULL;
> +		}
> +	}
> +
>  	for (i = 0; i < num_bufs; i++) {
>  		rte_pktmbuf_free(uncomp_bufs[i]);
>  		rte_pktmbuf_free(comp_bufs[i]);
>  		rte_comp_op_free(ops[i]);
>  		rte_comp_op_free(ops_processed[i]);
>  	}
> -	for (i = 0; i < num_priv_xforms; i++)
> -		if (priv_xforms[i] != NULL)
> -			rte_compressdev_private_xform_free(0,
> priv_xforms[i]);
> -	if (stream != NULL)
> -		rte_compressdev_stream_free(0, stream);
> -	if (all_decomp_data != NULL)
> -		rte_free(all_decomp_data);
>  	rte_free(contig_buf);
> 
>  	return ret_status;
> diff --git a/doc/guides/rel_notes/release_19_11.rst
> b/doc/guides/rel_notes/release_19_11.rst
> index 066bb3c19..5906f8b94 100644
> --- a/doc/guides/rel_notes/release_19_11.rst
> +++ b/doc/guides/rel_notes/release_19_11.rst
> @@ -152,6 +152,11 @@ New Features
>    Added eBPF JIT support for arm64 architecture to improve the eBPF
> program
>    performance.
> 
> +* **Refactored compression unit tests.**
> +
> +  Refactored core function to get clear code structure, better for
> maintenance.
> +  Created smaller specialized functions.
> +
> 
>  Removed Items
>  -------------
> --
> 2.17.1

Re: [dpdk-dev] [EXT] [PATCH v3 1/1] test/compress: unit tests refactoring

[Trybula, ArturX]

Hi Shally,

Please find my comments below.
 
> ----------------------------------------------------------------------
> Core engine refactoring (test_deflate_comp_decomp function).
> Smaller specialized functions created.
> 
> Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
> ---
>  app/test/test_compressdev.c            | 1118 +++++++++++++++++-------
>  doc/guides/rel_notes/release_19_11.rst |    5 +
>  2 files changed, 826 insertions(+), 297 deletions(-)
> 
> diff --git a/app/test/test_compressdev.c b/app/test/test_compressdev.c
> index 283c64971..4932bec76 100644
> --- a/app/test/test_compressdev.c
> +++ b/app/test/test_compressdev.c
> @@ -120,6 +120,20 @@ struct test_data_params {
>  	enum overflow_test overflow;
>  };
> 
> +struct test_private_arrays {
> +	struct rte_mbuf **uncomp_bufs;
> +	struct rte_mbuf **comp_bufs;
> +	struct rte_comp_op **ops;
> +	struct rte_comp_op **ops_processed;
> +	void **priv_xforms;
> +	uint64_t *compress_checksum;
> +	uint32_t *compressed_data_size;
> +	void **stream;
> +	char **all_decomp_data;
> +	unsigned int *decomp_produced_data_size;
> +	uint16_t num_priv_xforms;
> +};
> +
>  static struct comp_testsuite_params testsuite_params = { 0 };
> 
>  static void
> @@ -662,6 +676,7 @@ prepare_sgl_bufs(const char *test_buf, struct
> rte_mbuf *head_buf,
>  		data_size = remaining_data;
>  	else
>  		data_size = seg_size;
> +
>  	buf_ptr = rte_pktmbuf_append(head_buf, data_size);
>  	if (buf_ptr == NULL) {
>  		RTE_LOG(ERR, USER1,
> @@ -734,8 +749,9 @@ extbuf_free_callback(void *addr __rte_unused, void
> *opaque __rte_unused)  }
> 
>  static int
> -test_run_enqueue_dequeue(struct rte_comp_op **ops, unsigned int
> num_bufs,
> -		  struct rte_comp_op **ops_processed)
> +test_run_enqueue_dequeue(struct rte_comp_op **ops,
> +			 struct rte_comp_op **ops_processed,
> +			 unsigned int num_bufs)
>  {
>  	uint16_t num_enqd, num_deqd, num_total_deqd;
>  	unsigned int deqd_retries = 0;
> @@ -776,81 +792,77 @@ test_run_enqueue_dequeue(struct rte_comp_op
> **ops, unsigned int num_bufs,
>  	return 0;
>  }
> 
> -/*
> - * Compresses and decompresses buffer with compressdev API and Zlib API
> +/**
> + * Initialize all the arrays used in comp/decomp to NULL.
> + *
> + * If the length is greater than the length of the last segment, the
> + * function will fail and return -1 without modifying the mbuf.
> + *
> + * @param prv
> + *   A container used for aggregation all the arrays.
> + * @param num_bufs
> + *   The number of elements in each array.
> + */
> +static void
> +test_objects_init(struct test_private_arrays *prv,
> +		unsigned int num_bufs)
> +{
> +	/* Initialize all arrays to NULL */
> +	memset(prv->uncomp_bufs, 0, sizeof(struct rte_mbuf *) *
> num_bufs);
> +	memset(prv->comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
> +	memset(prv->ops, 0, sizeof(struct rte_comp_op *) * num_bufs);
> +	memset(prv->ops_processed, 0, sizeof(struct rte_comp_op *) *
> num_bufs);
> +	memset(prv->priv_xforms, 0, sizeof(void *) * num_bufs);
> +	memset(prv->compressed_data_size, 0, sizeof(uint32_t) *
> num_bufs); }
> +
Does it really matter what pointer is pointing to? Sizeof(any pointer) * num_bufs .. should be enough.
[Artur] You are absolutely right that sizeof() of any pointer gives the same result. But to be honest I don't understand your idea. Would you like to have an extra variable to initialise all the pointer arrays?
Eg:
uint32_t array_size = sizeof(void *) * num_bufs;
...
	memset(prv->uncomp_bufs, 0, array_size);
	memset(prv->comp_bufs, 0, array_size);
...


> +/**
> + * Source buffers preparation (for compression).
> + *
> + * Memory allocation for each buffer from mempool
> + * -1 returned if function fail, without modifying the mbuf.
> + *
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param priv_arrays
> + *   A container used for aggregation all the private test arrays.
> + * @return
> + *   - 0: On success.
> + *   - -1: On error.
>   */
>  static int
> -test_deflate_comp_decomp(const struct interim_data_params *int_data,
> -		const struct test_data_params *test_data)
> +test_mbufs_source_preparation(const struct interim_data_params
> *int_data,
> +		const struct test_data_params *test_data,
> +		const struct test_private_arrays *priv_arrays)
>  {
> +	/* local variables: */
> +	unsigned int i;
> +	uint32_t data_size;
> +	char *buf_ptr;
> +	int ret;
> +	char **all_decomp_data = priv_arrays->all_decomp_data;
> +
>  	struct comp_testsuite_params *ts_params = &testsuite_params;
> +
> +	/* from int_data: */
>  	const char * const *test_bufs = int_data->test_bufs;
>  	unsigned int num_bufs = int_data->num_bufs;
> -	uint16_t *buf_idx = int_data->buf_idx;
> -	struct rte_comp_xform **compress_xforms = int_data-
> >compress_xforms;
> -	struct rte_comp_xform **decompress_xforms = int_data-
> >decompress_xforms;
> -	unsigned int num_xforms = int_data->num_xforms;
> -	enum rte_comp_op_type compress_state = test_data-
> >compress_state;
> -	enum rte_comp_op_type decompress_state = test_data-
> >decompress_state;
> +
> +	/* from test_data: */
>  	unsigned int buff_type = test_data->buff_type;
> -	unsigned int out_of_space = test_data->out_of_space;
>  	unsigned int big_data = test_data->big_data;
> -	enum zlib_direction zlib_dir = test_data->zlib_dir;
> -	enum overflow_test overflow_tst = test_data->overflow;
> -	int ret_status = TEST_FAILED;
> -	struct rte_mbuf_ext_shared_info inbuf_info;
> -	struct rte_mbuf_ext_shared_info compbuf_info;
> -	struct rte_mbuf_ext_shared_info decompbuf_info;
> -	int ret;
> -	struct rte_mbuf *uncomp_bufs[num_bufs];
> -	struct rte_mbuf *comp_bufs[num_bufs];
> -	struct rte_comp_op *ops[num_bufs];
> -	struct rte_comp_op *ops_processed[num_bufs];
> -	void *priv_xforms[num_bufs];
> -	uint16_t num_enqd, num_deqd, num_total_deqd;
> -	uint16_t num_priv_xforms = 0;
> -	unsigned int deqd_retries = 0;
> -	struct priv_op_data *priv_data;
> -	char *buf_ptr;
> -	unsigned int i;
> -	struct rte_mempool *buf_pool;
> -	uint32_t data_size;
> -	/* Compressing with CompressDev */
> -	unsigned int oos_zlib_decompress =
> -			(zlib_dir == ZLIB_NONE || zlib_dir ==
> ZLIB_DECOMPRESS);
> -	/* Decompressing with CompressDev */
> -	unsigned int oos_zlib_compress =
> -			(zlib_dir == ZLIB_NONE || zlib_dir ==
> ZLIB_COMPRESS);
> -	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];
> -	uint32_t compressed_data_size[num_bufs];
> -	void *stream = NULL;
> -	char *all_decomp_data = NULL;
> -	unsigned int decomp_produced_data_size = 0;
> -	unsigned int step = 0;
> 
> -	TEST_ASSERT(decompress_state == RTE_COMP_OP_STATELESS ||
> num_bufs == 1,
> -		    "Number of stateful operations in a step should be 1");
> +	/* from priv_arrays: */
> +	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
> +	struct rte_mempool *buf_pool;
> 
> -	if (capa == NULL) {
> -		RTE_LOG(ERR, USER1,
> -			"Compress device does not support DEFLATE\n");
> -		return -ENOTSUP;
> -	}
> +	static struct rte_mbuf_ext_shared_info inbuf_info;
> 
> -	/* Initialize all arrays to NULL */
> -	memset(uncomp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
> -	memset(comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
> -	memset(ops, 0, sizeof(struct rte_comp_op *) * num_bufs);
> -	memset(ops_processed, 0, sizeof(struct rte_comp_op *) *
> num_bufs);
> -	memset(priv_xforms, 0, sizeof(void *) * num_bufs);
> -	memset(compressed_data_size, 0, sizeof(uint32_t) * num_bufs);
> -
> -	if (decompress_state == RTE_COMP_OP_STATEFUL) {
> +	if (test_data->decompress_state == RTE_COMP_OP_STATEFUL) {
>  		data_size = strlen(test_bufs[0]) + 1;
> -		all_decomp_data = rte_malloc(NULL, data_size,
> +		*all_decomp_data = rte_malloc(NULL, data_size,
>  					     RTE_CACHE_LINE_SIZE);
>  	}
> 
> @@ -861,14 +873,15 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  	else
>  		buf_pool = ts_params->large_mbuf_pool;
> 
> -	/* Prepare the source mbufs with the data */
> +	/* for compression uncomp_bufs is used as a source buffer */
> +	/* allocation from buf_pool (mempool type) */
>  	ret = rte_pktmbuf_alloc_bulk(buf_pool,
>  				uncomp_bufs, num_bufs);
>  	if (ret < 0) {
>  		RTE_LOG(ERR, USER1,
>  			"Source mbufs could not be allocated "
>  			"from the mempool\n");
> -		goto exit;
> +		return -1;
>  	}
> 
>  	if (test_data->use_external_mbufs) {
> @@ -881,8 +894,13 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  					test_data->inbuf_memzone->iova,
>  					test_data->inbuf_data_size,
>  					&inbuf_info);
> -			rte_pktmbuf_append(uncomp_bufs[i],
> +			buf_ptr = rte_pktmbuf_append(uncomp_bufs[i],
>  					test_data->inbuf_data_size);
> +			if (buf_ptr == NULL) {
> +				RTE_LOG(ERR, USER1,
> +					"Append extra bytes to the source
> mbuf failed\n");
> +				return -1;
> +			}
>  		}
>  	} else if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
>  		for (i = 0; i < num_bufs; i++) {
> @@ -893,106 +911,296 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  			    big_data ? buf_pool : ts_params-
> >large_mbuf_pool,
>  			    big_data ? 0 : MAX_SEGS,
>  			    big_data ? MAX_DATA_MBUF_SIZE :
> SMALL_SEG_SIZE) < 0)
> -				goto exit;
> +				return -1;
>  		}
>  	} 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);
>  			if (buf_ptr == NULL) {
>  				RTE_LOG(ERR, USER1,
>  					"Append extra bytes to the source
> mbuf failed\n");
> -				goto exit;
> +				return -1;
>  			}
>  			strlcpy(buf_ptr, test_bufs[i], data_size);
>  		}
>  	}
> 
> -	/* Prepare the destination mbufs */
> -	ret = rte_pktmbuf_alloc_bulk(buf_pool, comp_bufs, num_bufs);
> +	return 0;
> +}
> +
> +/**
> + * Data size calculation (for both compression and decompression).
> + *
> + * Developer is requested to provide input params
> + * according to the following rule:
> + *      if ops_processed == NULL -> compression
> + *      if ops_processed != NULL -> decompression
> + * Values bigger than 0 have to be returned to avoid problems
> + * with memory allocation
> + *
> + * @param ops_processed
> + *   Operations created as a result of compression phase. Should be
> + *   set to NULL for compression
> + * @param out_of_space_and_zlib
> + *   Boolean value to switch into "out of space" buffer if set.
> + *   To test "out-of-space" data size, zlib_decompress must be set as well.
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param i
> + *   current buffer index
> + * @return
> + *   - values bigger than 0
> + */
> +static inline uint32_t
> +test_mbufs_calculate_data_size(
> +		struct rte_comp_op *ops_processed[], /*can be equal to
> NULL*/
> +		unsigned int out_of_space_and_zlib,
> +		const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data,
> +		unsigned int i)
> +{
> +	/* local variables: */
> +	uint32_t data_size = 0;
> +	struct priv_op_data *priv_data;
> +	float ratio;
> +	uint8_t not_zlib_compr; /* true if zlib isn't current compression dev
> */
> +	enum overflow_test overflow = test_data->overflow;
> +
> +	/* from int_data: */
> +	const char * const *test_bufs = int_data->test_bufs;
> +
> +	if (out_of_space_and_zlib)
> +		data_size = OUT_OF_SPACE_BUF;
> +	else {
> +		if (ops_processed == NULL) {
> +
> +			not_zlib_compr = (test_data->zlib_dir ==
> ZLIB_DECOMPRESS
> +				|| test_data->zlib_dir == ZLIB_NONE);
> +
> +			ratio = (not_zlib_compr &&
> +				(overflow == OVERFLOW_ENABLED)) ?
> +				COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
> +				COMPRESS_BUF_SIZE_RATIO;
> +
> +			data_size = strlen(test_bufs[i]) * ratio;
> +
> +		} else {
> +			priv_data = (struct priv_op_data *)
> +					(ops_processed[i] + 1);
> +			data_size = strlen(test_bufs[priv_data->orig_idx]) +
> 1;
> +		}
> +	}
> +
> +	return data_size;
> +}
> +
> +
> +/**
> + * Memory buffers preparation (for both compression and decompression).
> + *
> + * Memory allocation for comp/decomp buffers from mempool, depending
> on
> + * ops_processed value. Developer is requested to provide input params
> + * according to the following rule:
> + *      if ops_processed == NULL -> current_bufs = comp_bufs[]
> + *      if ops_processed != NULL -> current_bufs = decomp_bufs[]
> + * -1 returned if function fail, without modifying the mbuf.
> + *
> + * @param ops_processed
> + *   Operations created as a result of compression phase. Should be
> + *   set to NULL for compression
> + * @param current_bufs
> + *   mbufs being prepared in the function.
> + * @param out_of_space_and_zlib
> + *   Boolean value to switch into "out of space" buffer if set.
> + *   To test "out-of-space" data size, zlib_decompress must be set as well.
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param current_extbuf_info,
> + *   The structure containing all the information related to external mbufs
> + * @param current_memzone
> + *   memzone used by external buffers
> + * @return
> + *   - 0: On success.
> + *   - -1: On error.
> + */
> +static int
> +test_mbufs_destination_preparation(
> +		struct rte_comp_op *ops_processed[], /*can be equal to
> NULL*/
> +		struct rte_mbuf *current_bufs[],
> +		unsigned int out_of_space_and_zlib,
> +		const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data,
> +		struct rte_mbuf_ext_shared_info *current_extbuf_info,
> +		const struct rte_memzone *current_memzone) {
> +	/* local variables: */
> +	unsigned int i;
> +	uint32_t data_size;
> +	int ret;
> +	char *buf_ptr;
> +
> +	struct comp_testsuite_params *ts_params = &testsuite_params;
> +
> +	/* from int_data: */
> +	unsigned int num_bufs = int_data->num_bufs;
> +
> +	/* from test_data: */
> +	unsigned int buff_type = test_data->buff_type;
> +	unsigned int big_data = test_data->big_data;
> +
> +	struct rte_mempool *buf_pool;
> +
> +	if (big_data)
> +		buf_pool = ts_params->big_mbuf_pool;
> +	else if (buff_type == SGL_BOTH)
> +		buf_pool = ts_params->small_mbuf_pool;
> +	else
> +		buf_pool = ts_params->large_mbuf_pool;
> +
> +	/* the mbufs allocation*/
> +	ret = rte_pktmbuf_alloc_bulk(buf_pool, current_bufs, num_bufs);
>  	if (ret < 0) {
>  		RTE_LOG(ERR, USER1,
>  			"Destination mbufs could not be allocated "
>  			"from the mempool\n");
> -		goto exit;
> +		return -1;
>  	}
> 
>  	if (test_data->use_external_mbufs) {
> -		compbuf_info.free_cb = extbuf_free_callback;
> -		compbuf_info.fcb_opaque = NULL;
> -		rte_mbuf_ext_refcnt_set(&compbuf_info, 1);
> +		current_extbuf_info->free_cb = extbuf_free_callback;
> +		current_extbuf_info->fcb_opaque = NULL;
> +		rte_mbuf_ext_refcnt_set(current_extbuf_info, 1);
>  		for (i = 0; i < num_bufs; i++) {
> -			rte_pktmbuf_attach_extbuf(comp_bufs[i],
> -					test_data->compbuf_memzone-
> >addr,
> -					test_data->compbuf_memzone-
> >iova,
> -					test_data->compbuf_memzone-
> >len,
> -					&compbuf_info);
> -			rte_pktmbuf_append(comp_bufs[i],
> -					test_data->compbuf_memzone-
> >len);
> +			rte_pktmbuf_attach_extbuf(current_bufs[i],
> +					current_memzone->addr,
> +					current_memzone->iova,
> +					current_memzone->len,
> +					current_extbuf_info);
> +			rte_pktmbuf_append(current_bufs[i],
> +					current_memzone->len);
>  		}
> -	} else if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
> -		for (i = 0; i < num_bufs; i++) {
> -			if (out_of_space == 1 && oos_zlib_decompress)
> -				data_size = OUT_OF_SPACE_BUF;
> -			else
> -				(data_size = strlen(test_bufs[i]) *
> -					COMPRESS_BUF_SIZE_RATIO);
> -
> -			if (prepare_sgl_bufs(NULL, comp_bufs[i],
> -			      data_size,
> -			      big_data ? buf_pool : ts_params-
> >small_mbuf_pool,
> -			      big_data ? buf_pool : ts_params-
> >large_mbuf_pool,
> -			      big_data ? 0 : MAX_SEGS,
> -			      big_data ? MAX_DATA_MBUF_SIZE :
> SMALL_SEG_SIZE)
> -					< 0)
> -				goto exit;
> -		}
> -
>  	} else {
>  		for (i = 0; i < num_bufs; i++) {
> -			if (out_of_space == 1 && oos_zlib_decompress)
> -				data_size = OUT_OF_SPACE_BUF;
> -			else {
> -				float ratio =
> -				((test_data->zlib_dir == ZLIB_DECOMPRESS
> ||
> -				   test_data->zlib_dir == ZLIB_NONE) &&
> -				  overflow_tst == OVERFLOW_ENABLED) ?
> -
> COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
> -					 COMPRESS_BUF_SIZE_RATIO;
> -
> -				data_size = strlen(test_bufs[i]) * ratio;
> -			}
> -			buf_ptr = rte_pktmbuf_append(comp_bufs[i],
> data_size);
> -			if (buf_ptr == NULL) {
> -				RTE_LOG(ERR, USER1,
> -					"Append extra bytes to the
> destination mbuf failed\n");
> -				goto exit;
> +
> +			/* data size calculation */
> +			data_size = test_mbufs_calculate_data_size(
> +					ops_processed,
> +					out_of_space_and_zlib,
> +					int_data,
> +					test_data,
> +					i);
> +
> +			/* data allocation */
> +			if (buff_type == SGL_BOTH || buff_type ==
> LB_TO_SGL) {
> +				ret = prepare_sgl_bufs(NULL,
> current_bufs[i],
> +				      data_size,
> +				      big_data ? buf_pool :
> +						ts_params-
> >small_mbuf_pool,
> +				      big_data ? buf_pool :
> +						ts_params-
> >large_mbuf_pool,
> +				      big_data ? 0 : MAX_SEGS,
> +				      big_data ? MAX_DATA_MBUF_SIZE :
> +						 SMALL_SEG_SIZE);
> +				if (ret < 0)
> +					return -1;
> +			} else {
> +				buf_ptr =
> rte_pktmbuf_append(current_bufs[i],
> +						data_size);
> +				if (buf_ptr == NULL) {
> +					RTE_LOG(ERR, USER1,
> +						"Append extra bytes to the
> destination mbuf failed\n");
> +					return -1;
> +				}
>  			}
>  		}
>  	}
> 
> +	return 0;
> +}
> +
> +/**
> + * The main compression function.
> + *
> + * Operation(s) configuration, depending on CLI parameters.
> + * Operation(s) processing.
> + * -1 returned if function fail.
> + *
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param priv_arrays
> + *   A container used for aggregation all the private test arrays.
> + * @return
> + *   - 0: On success.
> + *   - -1: On error.
> + */
> +static int
> +test_deflate_comp_run(const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data,
> +		const struct test_private_arrays *priv_arrays) {
> +	/* local variables: */
> +	struct priv_op_data *priv_data;
> +	unsigned int i;
> +	uint16_t num_priv_xforms = 0;
> +	int ret;
> +	int ret_status = 0;
> +	char *buf_ptr;
> +
> +	struct comp_testsuite_params *ts_params = &testsuite_params;
> +
> +	/* from test_data: */
> +	enum rte_comp_op_type operation_type = test_data-
> >compress_state;
> +	unsigned int zlib_compress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_COMPRESS);
> +
> +	/* from int_data: */
> +	struct rte_comp_xform **compress_xforms = int_data-
> >compress_xforms;
> +	unsigned int num_xforms = int_data->num_xforms;
> +	unsigned int num_bufs = int_data->num_bufs;
> +
> +	/* from priv_arrays: */
> +	struct rte_mbuf **comp_bufs = priv_arrays->comp_bufs;
> +	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
> +	struct rte_comp_op **ops = priv_arrays->ops;
> +	struct rte_comp_op **ops_processed = priv_arrays-
> >ops_processed;
> +	void **priv_xforms = priv_arrays->priv_xforms;
> +
> +	const struct rte_compressdev_capabilities *capa =
> +		rte_compressdev_capability_get(0,
> RTE_COMP_ALGO_DEFLATE);
> +
>  	/* Build the compression operations */
>  	ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops,
> num_bufs);
>  	if (ret < 0) {
>  		RTE_LOG(ERR, USER1,
>  			"Compress operations could not be allocated "
>  			"from the mempool\n");
> +		ret_status = -1;
>  		goto exit;
>  	}
> 
> -
>  	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;
> -		if (compress_state == RTE_COMP_OP_STATELESS)
> +
> +		if (operation_type == RTE_COMP_OP_STATELESS) {
>  			ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
> -		else {
> +		} else {
>  			RTE_LOG(ERR, USER1,
> -				"Stateful operations are not supported "
> -				"in these tests yet\n");
> +				"Compression: stateful operations are not "
> +				"supported in these tests yet\n");
> +			ret_status = -1;
>  			goto exit;
>  		}
>  		ops[i]->input_chksum = 0;
> @@ -1007,14 +1215,16 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  	}
> 
>  	/* Compress data (either with Zlib API or compressdev API */
> -	if (zlib_dir == ZLIB_COMPRESS || zlib_dir == ZLIB_ALL) {
> +	if (zlib_compress) {
>  		for (i = 0; i < num_bufs; i++) {
>  			const struct rte_comp_xform *compress_xform =
>  				compress_xforms[i % num_xforms];
>  			ret = compress_zlib(ops[i], compress_xform,
>  					DEFAULT_MEM_LEVEL);
> -			if (ret < 0)
> +			if (ret < 0) {
> +				ret_status = -1;
>  				goto exit;
> +			}
> 
>  			ops_processed[i] = ops[i];
>  		}
> @@ -1022,24 +1232,26 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  		/* Create compress private xform data */
>  		for (i = 0; i < num_xforms; i++) {
>  			ret = rte_compressdev_private_xform_create(0,
> -				(const struct rte_comp_xform
> *)compress_xforms[i],
> +				(const struct rte_comp_xform *)
> +					compress_xforms[i],
>  				&priv_xforms[i]);
>  			if (ret < 0) {
>  				RTE_LOG(ERR, USER1,
>  					"Compression private xform "
>  					"could not be created\n");
> +				ret_status = -1;
>  				goto exit;
>  			}
>  			num_priv_xforms++;
>  		}
> -
>  		if (capa->comp_feature_flags &
>  				RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
>  			/* Attach shareable private xform data to ops */
>  			for (i = 0; i < num_bufs; i++)
> -				ops[i]->private_xform = priv_xforms[i %
> num_xforms];
> +				ops[i]->private_xform =
> +						priv_xforms[i %
> num_xforms];
>  		} else {
> -			/* Create rest of the private xforms for the other ops
> */
> +		/* Create rest of the private xforms for the other ops */
>  			for (i = num_xforms; i < num_bufs; i++) {
>  				ret =
> rte_compressdev_private_xform_create(0,
>  					compress_xforms[i % num_xforms],
> @@ -1048,26 +1260,28 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  					RTE_LOG(ERR, USER1,
>  						"Compression private xform "
>  						"could not be created\n");
> +					ret_status = -1;
>  					goto exit;
>  				}
>  				num_priv_xforms++;
>  			}
> -
>  			/* Attach non shareable private xform data to ops */
>  			for (i = 0; i < num_bufs; i++)
>  				ops[i]->private_xform = priv_xforms[i];
>  		}
> 
>  recovery_lb:
> -		ret = test_run_enqueue_dequeue(ops, num_bufs,
> ops_processed);
> +		ret = test_run_enqueue_dequeue(ops, ops_processed,
> num_bufs);
>  		if (ret < 0) {
>  			RTE_LOG(ERR, USER1,
> -				"Enqueue/dequeue operation failed\n");
> +				"Compression: enqueue/dequeue operation
> failed\n");
> +			ret_status = -1;
>  			goto exit;
>  		}
> 
>  		for (i = 0; i < num_bufs; i++) {
> -			compressed_data_size[i] += ops_processed[i]-
> >produced;
> +			priv_arrays->compressed_data_size[i] +=
> +					ops_processed[i]->produced;
> 
>  			if (ops_processed[i]->status ==
> 
> 	RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE) { @@ -
> 1088,21 +1302,83 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  				if (buf_ptr == NULL) {
>  					RTE_LOG(ERR, USER1,
>  						"Data recovery: append extra
> bytes to the current mbuf failed\n");
> +					ret_status = -1;
>  					goto exit;
>  				}
>  				goto recovery_lb;
>  			}
>  		}
> -		deqd_retries = 0;
> +	}
> +
> +exit:
> +	/* Free resources */
> +	if (ret_status < 0)
> +		for (i = 0; i < num_bufs; i++) {
> +			rte_comp_op_free(ops[i]);
> +			ops_processed[i] = NULL;
> +		}
> 
> -		/* Free compress private xforms */
> -		for (i = 0; i < num_priv_xforms; i++) {
> +	/* Free compress private xforms */
> +	for (i = 0; i < num_priv_xforms; i++) {
> +		if (priv_xforms[i] != NULL) {
>  			rte_compressdev_private_xform_free(0,
> priv_xforms[i]);
>  			priv_xforms[i] = NULL;
>  		}
> -		num_priv_xforms = 0;
>  	}
> 
> +	return ret_status;
> +}
> +
> +/**
> + * Prints out the test report. Memory freeing.
> + *
> + * Called after successful compression.
> + * Operation(s) status validation and decompression buffers freeing.
> +
> + * -1 returned if function fail.
> + *
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param priv_arrays
> + *   A container used for aggregation all the private test arrays.
> + * @return
> + *   - 2: Some operation is not supported
> + *   - 1: Decompression should be skipped
> + *   - 0: On success.
> + *   - -1: On error.
> + */
> +static int
> +test_deflate_comp_finalize(const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data,
> +		const struct test_private_arrays *priv_arrays) {
> +	/* local variables: */
> +	unsigned int i;
> +	struct priv_op_data *priv_data;
> +
> +	/* from int_data: */
> +	unsigned int num_xforms = int_data->num_xforms;
> +	struct rte_comp_xform **compress_xforms = int_data-
> >compress_xforms;
> +	uint16_t *buf_idx = int_data->buf_idx;
> +	unsigned int num_bufs = int_data->num_bufs;
> +
> +	/* from priv_arrays: */
> +	struct rte_comp_op **ops_processed = priv_arrays-
> >ops_processed;
> +	uint64_t *compress_checksum = priv_arrays->compress_checksum;
> +	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
> +	struct rte_comp_op **ops = priv_arrays->ops;
> +
> +	/* from test_data: */
> +	unsigned int out_of_space = test_data->out_of_space;
> +	unsigned int zlib_compress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_COMPRESS);
> +	unsigned int zlib_decompress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_DECOMPRESS);
> +
>  	for (i = 0; i < num_bufs; i++) {
>  		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
>  		uint16_t xform_idx = priv_data->orig_idx % num_xforms;
> @@ -1111,7 +1387,7 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  		enum rte_comp_huffman huffman_type =
>  			compress_xform->deflate.huffman;
>  		char engine[] = "zlib (directly, not PMD)";
> -		if (zlib_dir != ZLIB_COMPRESS && zlib_dir != ZLIB_ALL)
> +		if (zlib_decompress)
>  			strlcpy(engine, "PMD", sizeof(engine));
> 
>  		RTE_LOG(DEBUG, USER1, "Buffer %u compressed by %s from
> %u to"
> @@ -1134,116 +1410,103 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  	 * compress operation information is needed for the decompression
> stage)
>  	 */
>  	for (i = 0; i < num_bufs; i++) {
> -		if (out_of_space && oos_zlib_decompress) {
> +		if (out_of_space && !zlib_compress) {
>  			if (ops_processed[i]->status !=
> 
> 	RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
> -				ret_status = TEST_FAILED;
>  				RTE_LOG(ERR, USER1,
>  					"Operation without expected out of "
>  					"space status error\n");
> -				goto exit;
> +				return -1;
>  			} else
>  				continue;
>  		}
> 
>  		if (ops_processed[i]->status !=
> RTE_COMP_OP_STATUS_SUCCESS) {
> -			if (overflow_tst == OVERFLOW_ENABLED) {
> +			if (test_data->overflow == OVERFLOW_ENABLED) {
>  				if (ops_processed[i]->status ==
> 
> 	RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
> -					ret_status = 1;
>  					RTE_LOG(INFO, USER1,
>  					"Out-of-space-recoverable
> functionality"
>  					" is not supported on this device\n");
> -					goto exit;
> +					return 2;
>  				}
>  			}
> +
>  			RTE_LOG(ERR, USER1,
>  				"Some operations were not successful\n");
> -			goto exit;
> +			return -1;
>  		}
>  		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
>  		rte_pktmbuf_free(uncomp_bufs[priv_data->orig_idx]);
>  		uncomp_bufs[priv_data->orig_idx] = NULL;
>  	}
> 
> -	if (out_of_space && oos_zlib_decompress) {
> -		ret_status = TEST_SUCCESS;
> -		goto exit;
> -	}
> +	if (out_of_space && !zlib_compress)
> +		return 1;
> 
> -	/* Allocate buffers for decompressed data */
> -	ret = rte_pktmbuf_alloc_bulk(buf_pool, uncomp_bufs, num_bufs);
> -	if (ret < 0) {
> -		RTE_LOG(ERR, USER1,
> -			"Destination mbufs could not be allocated "
> -			"from the mempool\n");
> -		goto exit;
> -	}
> +	return 0;
> +}
> 
> -	if (test_data->use_external_mbufs) {
> -		decompbuf_info.free_cb = extbuf_free_callback;
> -		decompbuf_info.fcb_opaque = NULL;
> -		rte_mbuf_ext_refcnt_set(&decompbuf_info, 1);
> -		for (i = 0; i < num_bufs; i++) {
> -			rte_pktmbuf_attach_extbuf(uncomp_bufs[i],
> -					test_data->uncompbuf_memzone-
> >addr,
> -					test_data->uncompbuf_memzone-
> >iova,
> -					test_data->uncompbuf_memzone-
> >len,
> -					&decompbuf_info);
> -			rte_pktmbuf_append(uncomp_bufs[i],
> -					test_data->uncompbuf_memzone-
> >len);
> -		}
> -	} else if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
> -		for (i = 0; i < num_bufs; i++) {
> -			priv_data = (struct priv_op_data *)
> -					(ops_processed[i] + 1);
> -			if (out_of_space == 1 && oos_zlib_compress)
> -				data_size = OUT_OF_SPACE_BUF;
> -			else if (test_data->decompress_output_block_size
> != 0)
> -				data_size =
> -					test_data-
> >decompress_output_block_size;
> -			else
> -				data_size =
> -				strlen(test_bufs[priv_data->orig_idx]) + 1;
> -
> -			if (prepare_sgl_bufs(NULL, uncomp_bufs[i],
> -			       data_size,
> -			       big_data ? buf_pool : ts_params-
> >small_mbuf_pool,
> -			       big_data ? buf_pool : ts_params-
> >large_mbuf_pool,
> -			       big_data ? 0 : MAX_SEGS,
> -			       big_data ? MAX_DATA_MBUF_SIZE :
> SMALL_SEG_SIZE)
> -					< 0)
> -				goto exit;
> -		}
> +/**
> + * The main decompression function.
> + *
> + * Operation(s) configuration, depending on CLI parameters.
> + * Operation(s) processing.
> + * -1 returned if function fail.
> + *
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param priv_arrays
> + *   A container used for aggregation all the private test arrays.
> + * @return
> + *   - 0: On success.
> + *   - -1: On error.
> + */
> +static int
> +test_deflate_decomp_run(const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data,
> +		struct test_private_arrays *priv_arrays) {
> 
> -	} else {
> -		for (i = 0; i < num_bufs; i++) {
> -			priv_data = (struct priv_op_data *)
> -					(ops_processed[i] + 1);
> -			if (out_of_space == 1 && oos_zlib_compress)
> -				data_size = OUT_OF_SPACE_BUF;
> -			else if (test_data->decompress_output_block_size
> != 0)
> -				data_size =
> -					test_data-
> >decompress_output_block_size;
> -			else
> -				data_size =
> -				strlen(test_bufs[priv_data->orig_idx]) + 1;
> +	/* local variables: */
> +	struct priv_op_data *priv_data;
> +	unsigned int i;
> +	uint16_t num_priv_xforms = 0;
> +	int ret;
> +	int ret_status = 0;
> 
> -			buf_ptr = rte_pktmbuf_append(uncomp_bufs[i],
> data_size);
> -			if (buf_ptr == NULL) {
> -				RTE_LOG(ERR, USER1,
> -					"Append extra bytes to the
> decompressed mbuf failed\n");
> -				goto exit;
> -			}
> -		}
> -	}
> +	struct comp_testsuite_params *ts_params = &testsuite_params;
> +
> +	/* from test_data: */
> +	enum rte_comp_op_type operation_type = test_data-
> >decompress_state;
> +	unsigned int zlib_decompress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_DECOMPRESS);
> +
> +	/* from int_data: */
> +	struct rte_comp_xform **decompress_xforms = int_data-
> >decompress_xforms;
> +	unsigned int num_xforms = int_data->num_xforms;
> +	unsigned int num_bufs = int_data->num_bufs;
> +
> +	/* from priv_arrays: */
> +	struct rte_mbuf **uncomp_bufs = priv_arrays->uncomp_bufs;
> +	struct rte_comp_op **ops = priv_arrays->ops;
> +	struct rte_comp_op **ops_processed = priv_arrays-
> >ops_processed;
> +	void **priv_xforms = priv_arrays->priv_xforms;
> +	uint32_t *compressed_data_size = priv_arrays-
> >compressed_data_size;
> +	void **stream = priv_arrays->stream;
> +
> +	const struct rte_compressdev_capabilities *capa =
> +		rte_compressdev_capability_get(0,
> RTE_COMP_ALGO_DEFLATE);
> 
> -	/* Build the decompression operations */
>  	ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops,
> num_bufs);
>  	if (ret < 0) {
>  		RTE_LOG(ERR, USER1,
>  			"Decompress operations could not be allocated "
>  			"from the mempool\n");
> +		ret_status = -1;
>  		goto exit;
>  	}
> 
> @@ -1256,22 +1519,25 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  		 * Set the length of the compressed data to the
>  		 * number of bytes that were produced in the previous stage
>  		 */
> +
>  		if (compressed_data_size[i])
>  			ops[i]->src.length = compressed_data_size[i];
>  		else
>  			ops[i]->src.length = ops_processed[i]->produced;
> 
>  		ops[i]->dst.offset = 0;
> -		if (decompress_state == RTE_COMP_OP_STATELESS) {
> +
> +		if (operation_type == RTE_COMP_OP_STATELESS) {
>  			ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
>  			ops[i]->op_type = RTE_COMP_OP_STATELESS;
> -		} else if (zlib_dir == ZLIB_COMPRESS || zlib_dir ==
> ZLIB_NONE) {
> +		} else if (!zlib_decompress) {
>  			ops[i]->flush_flag = RTE_COMP_FLUSH_SYNC;
>  			ops[i]->op_type = RTE_COMP_OP_STATEFUL;
>  		} else {
>  			RTE_LOG(ERR, USER1,
> -				"Stateful operations are not supported "
> -				"in these tests yet\n");
> +				"Decompression: stateful operations are"
> +				" not supported in these tests yet\n");
> +			ret_status = -1;
>  			goto exit;
>  		}
>  		ops[i]->input_chksum = 0;
> @@ -1290,7 +1556,7 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  	rte_comp_op_bulk_free(ops_processed, num_bufs);
> 
>  	/* Decompress data (either with Zlib API or compressdev API */
> -	if (zlib_dir == ZLIB_DECOMPRESS || zlib_dir == ZLIB_ALL) {
> +	if (zlib_decompress) {
>  		for (i = 0; i < num_bufs; i++) {
>  			priv_data = (struct priv_op_data *)(ops[i] + 1);
>  			uint16_t xform_idx = priv_data->orig_idx %
> num_xforms; @@ -1298,13 +1564,15 @@ test_deflate_comp_decomp(const
> struct interim_data_params *int_data,
>  				decompress_xforms[xform_idx];
> 
>  			ret = decompress_zlib(ops[i], decompress_xform);
> -			if (ret < 0)
> +			if (ret < 0) {
> +				ret_status = -1;
>  				goto exit;
> +			}
> 
>  			ops_processed[i] = ops[i];
>  		}
>  	} else {
> -		if (decompress_state == RTE_COMP_OP_STATELESS) {
> +		if (operation_type == RTE_COMP_OP_STATELESS) {
>  			/* Create decompress private xform data */
>  			for (i = 0; i < num_xforms; i++) {
>  				ret =
> rte_compressdev_private_xform_create(0,
> @@ -1315,6 +1583,7 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  					RTE_LOG(ERR, USER1,
>  						"Decompression private
> xform "
>  						"could not be created\n");
> +					ret_status = -1;
>  					goto exit;
>  				}
>  				num_priv_xforms++;
> @@ -1341,7 +1610,9 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  					      &priv_xforms[i]);
>  					if (ret < 0) {
>  						RTE_LOG(ERR, USER1,
> -							"Decompression
> private xform could not be created\n");
> +							"Decompression
> private xform"
> +							" could not be
> created\n");
> +						ret_status = -1;
>  						goto exit;
>  					}
>  					num_priv_xforms++;
> @@ -1361,59 +1632,86 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  		} else {
>  			/* Create a stream object for stateful decompression
> */
>  			ret = rte_compressdev_stream_create(0,
> -					decompress_xforms[0], &stream);
> +					decompress_xforms[0], stream);
>  			if (ret < 0) {
>  				RTE_LOG(ERR, USER1,
>  					"Decompression stream could not be
> created, error %d\n",
>  					ret);
> +				ret_status = -1;
>  				goto exit;
>  			}
>  			/* Attach stream to ops */
>  			for (i = 0; i < num_bufs; i++)
> -				ops[i]->stream = stream;
> +				ops[i]->stream = *stream;
>  		}
> 
> -next_step:
> -		/* Enqueue and dequeue all operations */
> -		num_enqd = rte_compressdev_enqueue_burst(0, 0, ops,
> num_bufs);
> -		if (num_enqd < num_bufs) {
> -			RTE_LOG(ERR, USER1,
> -				"The operations could not be enqueued\n");
> -			goto exit;
> -		}
> +		priv_arrays->num_priv_xforms = num_priv_xforms;
> +	}
> 
> -		num_total_deqd = 0;
> -		do {
> -			/*
> -			 * If retrying a dequeue call, wait for 10 ms to allow
> -			 * enough time to the driver to process the
> operations
> -			 */
> -			if (deqd_retries != 0) {
> -				/*
> -				 * Avoid infinite loop if not all the
> -				 * operations get out of the device
> -				 */
> -				if (deqd_retries == MAX_DEQD_RETRIES) {
> -					RTE_LOG(ERR, USER1,
> -						"Not all operations could be "
> -						"dequeued\n");
> -					goto exit;
> -				}
> -				usleep(DEQUEUE_WAIT_TIME);
> -			}
> -			num_deqd = rte_compressdev_dequeue_burst(0, 0,
> -					&ops_processed[num_total_deqd],
> num_bufs);
> -			num_total_deqd += num_deqd;
> -			deqd_retries++;
> -		} while (num_total_deqd < num_enqd);
> +exit:
> +	return ret_status;
> +}
> 
> -		deqd_retries = 0;
> -	}
> +/**
> + * Prints out the test report. Memory freeing.
> + *
> + * Called after successful decompression.
> + * Operation(s) status validation and compression buffers freeing.
> +
> + * -1 returned if function fail.
> + *
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param priv_arrays
> + *   A container used for aggregation all the private test arrays.
> + * @return
> + *   - 2: Next step must be executed by the caller (stateful decompression
> only)
> + *   - 1: On success (caller should stop and exit)
> + *   - 0: On success.
> + *   - -1: On error.
> + */
> +static int
> +test_deflate_decomp_finalize(const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data,
> +		const struct test_private_arrays *priv_arrays) {
> +	/* local variables: */
> +	unsigned int i;
> +	struct priv_op_data *priv_data;
> +	static unsigned int step;
> +
> +	/* from int_data: */
> +	uint16_t *buf_idx = int_data->buf_idx;
> +	unsigned int num_bufs = int_data->num_bufs;
> +	const char * const *test_bufs = int_data->test_bufs;
> +	struct rte_comp_xform **compress_xforms = int_data-
> >compress_xforms;
> +
> +	/* from priv_arrays: */
> +	struct rte_comp_op **ops_processed = priv_arrays-
> >ops_processed;
> +	struct rte_mbuf **comp_bufs = priv_arrays->comp_bufs;
> +	struct rte_comp_op **ops = priv_arrays->ops;
> +	uint64_t *compress_checksum = priv_arrays->compress_checksum;
> +	unsigned int *decomp_produced_data_size =
> +			priv_arrays->decomp_produced_data_size;
> +	char **all_decomp_data = priv_arrays->all_decomp_data;
> +
> +	/* from test_data: */
> +	unsigned int out_of_space = test_data->out_of_space;
> +	enum rte_comp_op_type operation_type = test_data-
> >decompress_state;
> +
> +	unsigned int zlib_compress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_COMPRESS);
> +	unsigned int zlib_decompress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_DECOMPRESS);
> 
>  	for (i = 0; i < num_bufs; i++) {
>  		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
>  		char engine[] = "zlib, (directly, no PMD)";
> -		if (zlib_dir != ZLIB_DECOMPRESS && zlib_dir != ZLIB_ALL)
> +		if (zlib_compress)
>  			strlcpy(engine, "pmd", sizeof(engine));
>  		RTE_LOG(DEBUG, USER1,
>  			"Buffer %u decompressed by %s from %u to %u
> bytes\n", @@ -1427,19 +1725,19 @@ test_deflate_comp_decomp(const
> struct interim_data_params *int_data,
>  	 * compress operation information is still needed)
>  	 */
>  	for (i = 0; i < num_bufs; i++) {
> -		if (out_of_space && oos_zlib_compress) {
> +		if (out_of_space && !zlib_decompress) {
>  			if (ops_processed[i]->status !=
> -
> 	RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
> -				ret_status = TEST_FAILED;
> +
> 	RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
> +
>  				RTE_LOG(ERR, USER1,
>  					"Operation without expected out of "
>  					"space status error\n");
> -				goto exit;
> +				return -1;
>  			} else
>  				continue;
>  		}
> 
> -		if (decompress_state == RTE_COMP_OP_STATEFUL
> +		if (operation_type == RTE_COMP_OP_STATEFUL
>  			&& (ops_processed[i]->status ==
> 
> 	RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE
>  			    || ops_processed[i]->status ==
> @@ -1449,28 +1747,29 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  					ops_processed[i]->m_dst,
>  					ops_processed[i]->dst.offset,
>  					ops_processed[i]->produced,
> -					all_decomp_data +
> -
> 	decomp_produced_data_size);
> -			if (ptr != all_decomp_data +
> decomp_produced_data_size)
> -				rte_memcpy(all_decomp_data +
> -					   decomp_produced_data_size,
> +					*all_decomp_data +
> +
> 	*decomp_produced_data_size);
> +			if (ptr != *all_decomp_data +
> +					*decomp_produced_data_size)
> +				rte_memcpy(*all_decomp_data +
> +					   *decomp_produced_data_size,
>  					   ptr, ops_processed[i]->produced);
> -			decomp_produced_data_size += ops_processed[i]-
> >produced;
> +
> +			*decomp_produced_data_size +=
> +					ops_processed[i]->produced;
>  			if (ops_processed[i]->src.length >
>  					ops_processed[i]->consumed) {
>  				if (ops_processed[i]->status ==
> 
> 	RTE_COMP_OP_STATUS_SUCCESS) {
> -					ret_status = -1;
>  					RTE_LOG(ERR, USER1,
>  					      "Operation finished too early\n");
> -					goto exit;
> +					return -1;
>  				}
>  				step++;
>  				if (step >= test_data-
> >decompress_steps_max) {
> -					ret_status = -1;
>  					RTE_LOG(ERR, USER1,
>  					  "Operation exceeded maximum
> steps\n");
> -					goto exit;
> +					return -1;
>  				}
>  				ops[i] = ops_processed[i];
>  				ops[i]->status =
> @@ -1479,7 +1778,9 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  						ops_processed[i]-
> >consumed;
>  				ops[i]->src.length -=
>  						ops_processed[i]-
> >consumed;
> -				goto next_step;
> +				/* repeat the operation */
> +				//goto next_step;
> +				return 2;
>  			} else {
>  				/* Compare the original stream with the */
>  				/* decompressed stream (in size and the
> data) */ @@ -1487,22 +1788,22 @@ test_deflate_comp_decomp(const
> struct interim_data_params *int_data,
>  						(ops_processed[i] + 1);
>  				const char *buf1 =
>  						test_bufs[priv_data-
> >orig_idx];
> -				const char *buf2 = all_decomp_data;
> +				const char *buf2 = *all_decomp_data;
> 
>  				if (compare_buffers(buf1, strlen(buf1) + 1,
> -					  buf2, decomp_produced_data_size)
> < 0)
> -					goto exit;
> +					  buf2,
> *decomp_produced_data_size) < 0)
> +					return -1;
>  				/* 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],
> +			"The checksums differ\n"
> +			"Compression Checksum: %" PRIu64
> "\tDecompression "
> +			"Checksum: %" PRIu64 "\n", compress_checksum[i],
>  					       ops_processed[i]-
> >output_chksum);
> -						goto exit;
> +						return -1;
>  					}
>  				}
>  			}
> @@ -1510,18 +1811,58 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  			   RTE_COMP_OP_STATUS_SUCCESS) {
>  			RTE_LOG(ERR, USER1,
>  				"Some operations were not successful\n");
> -			goto exit;
> +			return -1;
>  		}
>  		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
>  		rte_pktmbuf_free(comp_bufs[priv_data->orig_idx]);
>  		comp_bufs[priv_data->orig_idx] = NULL;
>  	}
> 
> -	if ((out_of_space && oos_zlib_compress)
> -			|| (decompress_state ==
> RTE_COMP_OP_STATEFUL)) {
> -		ret_status = TEST_SUCCESS;
> -		goto exit;
> -	}
> +	if (out_of_space && !zlib_decompress)
> +		return 1;
> +
> +	return 0;
> +}
> +
> +/**
> + * Validation of the output (compression/decompression) data.
> + *
> + * The function compares the source stream with the output stream,
> + * after decompression, to check if compression/decompression
> + * was correct.
> + * -1 returned if function fail.
> + *
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @param priv_arrays
> + *   A container used for aggregation all the private test arrays.
> + * @return
> + *   - 0: On success.
> + *   - -1: On error.
> + */
> +static int
> +test_results_validation(const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data,
> +		const struct test_private_arrays *priv_arrays) {
> +	/* local variables: */
> +	unsigned int i;
> +	struct priv_op_data *priv_data;
> +	const char *buf1;
> +	const char *buf2;
> +	char *contig_buf = NULL;
> +	uint32_t data_size;
> +
> +	/* from int_data: */
> +	struct rte_comp_xform **compress_xforms = int_data-
> >compress_xforms;
> +	unsigned int num_bufs = int_data->num_bufs;
> +	const char * const *test_bufs = int_data->test_bufs;
> +
> +	/* from priv_arrays: */
> +	uint64_t *compress_checksum = priv_arrays->compress_checksum;
> +	struct rte_comp_op **ops_processed = priv_arrays-
> >ops_processed;
> 
>  	/*
>  	 * Compare the original stream with the decompressed stream @@ -
> 1529,13 +1870,13 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  	 */
>  	for (i = 0; i < num_bufs; i++) {
>  		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
> -		const char *buf1 = test_data->use_external_mbufs ?
> +		buf1 = test_data->use_external_mbufs ?
>  				test_data->inbuf_memzone->addr :
>  				test_bufs[priv_data->orig_idx];
> -		const char *buf2;
>  		data_size = test_data->use_external_mbufs ?
>  				test_data->inbuf_data_size :
>  				strlen(buf1) + 1;
> +
>  		contig_buf = rte_malloc(NULL, ops_processed[i]->produced,
> 0);
>  		if (contig_buf == NULL) {
>  			RTE_LOG(ERR, USER1, "Contiguous buffer could not "
> @@ -1565,24 +1906,207 @@ test_deflate_comp_decomp(const struct
> interim_data_params *int_data,
>  		rte_free(contig_buf);
>  		contig_buf = NULL;
>  	}
> +	return 0;
> +
> +exit:
> +	rte_free(contig_buf);
> +	return -1;
> +}
> +
> +/**
> + * Compresses and decompresses input stream with compressdev API and
> +Zlib API
> + *
> + * Basic test function. Common for all the functional tests.
> + * -1 returned if function fail.
> + *
> + * @param int_data
> + *   Interim data containing session/transformation objects.
> + * @param test_data
> + *   The test parameters set by users (command line parameters).
> + * @return
> + *   - 1: Some operation not supported
> + *   - 0: On success.
> + *   - -1: On error.
> + */
> +
> +static int
> +test_deflate_comp_decomp(const struct interim_data_params *int_data,
> +		const struct test_data_params *test_data) {
> +	unsigned int num_bufs = int_data->num_bufs;
> +	unsigned int out_of_space = test_data->out_of_space;
> +
> +	void *stream = NULL;
> +	char *all_decomp_data = NULL;
> +	unsigned int decomp_produced_data_size = 0;
> +
> +	int ret_status = -1;
> +	int ret;
> +	struct rte_mbuf *uncomp_bufs[num_bufs];
> +	struct rte_mbuf *comp_bufs[num_bufs];
> +	struct rte_comp_op *ops[num_bufs];
> +	struct rte_comp_op *ops_processed[num_bufs];
> +	void *priv_xforms[num_bufs];
> +	unsigned int i;
> +
> +	uint64_t compress_checksum[num_bufs];
> +	uint32_t compressed_data_size[num_bufs];
> +	char *contig_buf = NULL;
> +
> +	struct rte_mbuf_ext_shared_info compbuf_info;
> +	struct rte_mbuf_ext_shared_info decompbuf_info;
> +
> +	const struct rte_compressdev_capabilities *capa;
> +
> +	/* Compressing with CompressDev */
> +	unsigned int zlib_compress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_COMPRESS);
> +	unsigned int zlib_decompress =
> +			(test_data->zlib_dir == ZLIB_ALL ||
> +			test_data->zlib_dir == ZLIB_DECOMPRESS);
> +
> +	struct test_private_arrays priv_arrays;
> +
> +	priv_arrays.uncomp_bufs = uncomp_bufs;
> +	priv_arrays.comp_bufs = comp_bufs;
> +	priv_arrays.ops = ops;
> +	priv_arrays.ops_processed = ops_processed;
> +	priv_arrays.priv_xforms = priv_xforms;
> +	priv_arrays.compress_checksum = compress_checksum;
> +	priv_arrays.compressed_data_size = compressed_data_size;
> +
> +	priv_arrays.stream = &stream;
> +	priv_arrays.all_decomp_data = &all_decomp_data;
> +	priv_arrays.decomp_produced_data_size =
> &decomp_produced_data_size;
> +
> +	priv_arrays.num_priv_xforms = 0; /* it's used for deompression only
> */
> +
> +	capa = rte_compressdev_capability_get(0,
> RTE_COMP_ALGO_DEFLATE);
> +	if (capa == NULL) {
> +		RTE_LOG(ERR, USER1,
> +			"Compress device does not support DEFLATE\n");
> +		return -1;
> +	}
> +	test_objects_init(&priv_arrays, num_bufs);
Do we need this? Why we just cant call source_prep API? That will also setup uncompressed_bufs
[Artur] This is my approach. Do you prefer to have arrays initialisation moved to test_mbufs_source_preparation? 
If "yes", test_objects_init will be removed from the code.

> +
> +	/* Prepare the source mbufs with the data */
> +	ret = test_mbufs_source_preparation(int_data, test_data,
> &priv_arrays);
For code readability sake, it could test_setup_uncom_bufs() 
[Artur] Good idea. Would it be ok if I change:
1. test_mbufs_destination_preparation  into test_setup_uncom_bufs
2. test_mbufs_source_preparation into test_setup_com_bufs

> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	}
> +
> +/* COMPRESSION  */
> +
> +	/* Prepare the destination mbufs */
> +	ret = test_mbufs_destination_preparation(
Why we cant keep this prototype same as source_preparation() API for better readability?
I mean we can pass priv_arry here too...
[Artur] To get better readability it has been implemented in this way. That was only my point of view but I don't mind to modify the code according to your suggestion. It's also ok.

> +			NULL, /*can be equal to NULL*/
> +			comp_bufs,
> +			out_of_space == 1 && !zlib_compress,
> +			int_data,
> +			test_data,
> +			&compbuf_info,
> +			test_data->compbuf_memzone);
> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	}
> +
> +	/* Run compression */
> +	ret = test_deflate_comp_run(int_data, test_data, &priv_arrays);
> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	}
> +
> +	ret = test_deflate_comp_finalize(int_data, test_data, &priv_arrays);
> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	} else if (ret == 1) {
> +		ret_status = 0;
> +		goto exit;
> +	} else if (ret == 2) {
> +		ret_status = 1;	 /* some operation not supported */
> +		goto exit;
> +	}
> +
> +/* DECOMPRESSION  */
> +
> +	/* Allocate buffers for decompressed data */
> +	ret = test_mbufs_destination_preparation(
> +			ops_processed, /*can be equal to NULL*/
> +			uncomp_bufs,
> +			out_of_space == 1 && !zlib_decompress,
> +			int_data,
> +			test_data,
> +			&decompbuf_info,
> +			test_data->uncompbuf_memzone);
> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	}
> +
> +	/* Run decompression */
> +	ret = test_deflate_decomp_run(int_data, test_data, &priv_arrays);
> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	}
> +
> +	if (!zlib_decompress) {
> +next_step:	/* next step for stateful decompression only */
> +		ret = test_run_enqueue_dequeue(ops, ops_processed,
> num_bufs);
> +		if (ret < 0) {
> +			ret_status = -1;
> +			RTE_LOG(ERR, USER1,
> +				"Decompression: enqueue/dequeue
> operation failed\n");
> +		}
> +	}
> 
> -	ret_status = TEST_SUCCESS;
> +	ret = test_deflate_decomp_finalize(int_data, test_data,
> &priv_arrays);
> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	} else if (ret == 1) {
> +		ret_status = 0;
> +		goto exit;
> +	} else if (ret == 2) {
> +		goto next_step;
> +	}
> +
> +/* FINAL PROCESSING  */
> +
> +	ret = test_results_validation(int_data, test_data, &priv_arrays);
> +	if (ret < 0) {
> +		ret_status = -1;
> +		goto exit;
> +	}
> +	ret_status = 0;
> 
>  exit:
>  	/* Free resources */
> +
> +	if (stream != NULL)
> +		rte_compressdev_stream_free(0, stream);
> +	if (all_decomp_data != NULL)
> +		rte_free(all_decomp_data);
> +
> +	/* Free compress private xforms */
> +	for (i = 0; i < priv_arrays.num_priv_xforms; i++) {
> +		if (priv_xforms[i] != NULL) {
> +			rte_compressdev_private_xform_free(0,
> priv_xforms[i]);
> +			priv_xforms[i] = NULL;
> +		}
> +	}
> +
>  	for (i = 0; i < num_bufs; i++) {
>  		rte_pktmbuf_free(uncomp_bufs[i]);
>  		rte_pktmbuf_free(comp_bufs[i]);
>  		rte_comp_op_free(ops[i]);
>  		rte_comp_op_free(ops_processed[i]);
>  	}
> -	for (i = 0; i < num_priv_xforms; i++)
> -		if (priv_xforms[i] != NULL)
> -			rte_compressdev_private_xform_free(0,
> priv_xforms[i]);
> -	if (stream != NULL)
> -		rte_compressdev_stream_free(0, stream);
> -	if (all_decomp_data != NULL)
> -		rte_free(all_decomp_data);
>  	rte_free(contig_buf);
> 
>  	return ret_status;
> diff --git a/doc/guides/rel_notes/release_19_11.rst
> b/doc/guides/rel_notes/release_19_11.rst
> index 066bb3c19..5906f8b94 100644
> --- a/doc/guides/rel_notes/release_19_11.rst
> +++ b/doc/guides/rel_notes/release_19_11.rst
> @@ -152,6 +152,11 @@ New Features
>    Added eBPF JIT support for arm64 architecture to improve the eBPF
> program
>    performance.
> 
> +* **Refactored compression unit tests.**
> +
> +  Refactored core function to get clear code structure, better for
> maintenance.
> +  Created smaller specialized functions.
> +
> 
>  Removed Items
>  -------------
> --
> 2.17.1

Re: [dpdk-dev] [EXT] [PATCH v3 1/1] test/compress: unit tests refactoring

[Shally Verma]

> -----Original Message-----
> From: Trybula, ArturX <arturx.trybula@intel.com>
> Sent: Monday, November 4, 2019 3:55 PM
> To: Shally Verma <shallyv@marvell.com>; dev@dpdk.org; Trahe, Fiona
> <fiona.trahe@intel.com>; Dybkowski, AdamX
> <adamx.dybkowski@intel.com>; akhil.goyal@nxp.com
> Subject: RE: [EXT] [PATCH v3 1/1] test/compress: unit tests refactoring
> 
> Hi Shally,
> 
> Please find my comments below.
> 
> > ----------------------------------------------------------------------
> > Core engine refactoring (test_deflate_comp_decomp function).
> > Smaller specialized functions created.
> >
> > Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
> > ---
> >  app/test/test_compressdev.c            | 1118 +++++++++++++++++-------
> >  doc/guides/rel_notes/release_19_11.rst |    5 +
> >  2 files changed, 826 insertions(+), 297 deletions(-)
> >
.....
> > +static void
> > +test_objects_init(struct test_private_arrays *prv,
> > +		unsigned int num_bufs)
> > +{
> > +	/* Initialize all arrays to NULL */
> > +	memset(prv->uncomp_bufs, 0, sizeof(struct rte_mbuf *) *
> > num_bufs);
> > +	memset(prv->comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
> > +	memset(prv->ops, 0, sizeof(struct rte_comp_op *) * num_bufs);
> > +	memset(prv->ops_processed, 0, sizeof(struct rte_comp_op *) *
> > num_bufs);
> > +	memset(prv->priv_xforms, 0, sizeof(void *) * num_bufs);
> > +	memset(prv->compressed_data_size, 0, sizeof(uint32_t) *
> > num_bufs); }
> > +
> Does it really matter what pointer is pointing to? Sizeof(any pointer) *
> num_bufs .. should be enough.
> [Artur] You are absolutely right that sizeof() of any pointer gives the same
> result. But to be honest I don't understand your idea. Would you like to have
> an extra variable to initialise all the pointer arrays?
> Eg:
> uint32_t array_size = sizeof(void *) * num_bufs;
> ...
> 	memset(prv->uncomp_bufs, 0, array_size);
> 	memset(prv->comp_bufs, 0, array_size);
> ...
[Shally] Hmm... ya that sort of. But my 2cents on it. So, its up to you .

> 
> 
> > +/**
> > + * Source buffers preparation (for compression).
> > + *
[Shally] Can we have more details here like: API that allocates input (and output buffers?) to perform compression operations?

> > + * Memory allocation for each buffer from mempool
> > + * -1 returned if function fail, without modifying the mbuf.
> > + *
> > + * @param int_data
[Shally] Can we change it to name test_params?

> > + *   Interim data containing session/transformation objects.
> > + * @param test_data
> > + *   The test parameters set by users (command line parameters).
> > + * @param priv_arrays
[Shally] Can we change it to name test_priv_data?

> > + *   A container used for aggregation all the private test arrays.
> > + * @return
> > + *   - 0: On success.
> > + *   - -1: On error.
> >   */
> >  static int
> > -test_deflate_comp_decomp(const struct interim_data_params *int_data,
> > -		const struct test_data_params *test_data)
> > +test_mbufs_source_preparation(const struct interim_data_params
> > *int_data,
> > +		const struct test_data_params *test_data,
> > +		const struct test_private_arrays *priv_arrays)
> >  {
....

> > +/**
> > + * Data size calculation (for both compression and decompression).
> > + *
[Shally] Can add more details here like calculate size of anticipated output buffer required for both compression and decompression operations based on input test_params.
Caller then allocate output buffer based on size returned by this function.

> > + * Developer is requested to provide input params
> > + * according to the following rule:
> > + *      if ops_processed == NULL -> compression
> > + *      if ops_processed != NULL -> decompression
[Shally] we are trying to  overload its purpose here. Can it be make simpler . we can use interim test param to check if op type is compression/decompression and then use op_processed[] on need basis
This will help in code readability else function looks complex to understand where as purpose is very simple.

> > + * Values bigger than 0 have to be returned to avoid problems
> > + * with memory allocation
> > + *
[Shally] Can be reworded as " function return non-zero on success, 0 on failure. Caller should not allocate memory if 0. 

> > + * @param ops_processed
> > + *   Operations created as a result of compression phase. Should be
> > + *   set to NULL for compression
> > + * @param out_of_space_and_zlib
> > + *   Boolean value to switch into "out of space" buffer if set.
> > + *   To test "out-of-space" data size, zlib_decompress must be set as well.
> > + * @param int_data
> > + *   Interim data containing session/transformation objects.
> > + * @param test_data
> > + *   The test parameters set by users (command line parameters).
> > + * @param i
> > + *   current buffer index
> > + * @return
> > + *   - values bigger than 0
> > + */
> > +static inline uint32_t
> > +test_mbufs_calculate_data_size(
> > +		struct rte_comp_op *ops_processed[], /*can be equal to
> > NULL*/
> > +		unsigned int out_of_space_and_zlib,
> > +		const struct interim_data_params *int_data,
> > +		const struct test_data_params *test_data,
> > +		unsigned int i)
> > +{
> > +	/* local variables: */
> > +	uint32_t data_size = 0;
> > +	struct priv_op_data *priv_data;
> > +	float ratio;
> > +	uint8_t not_zlib_compr; /* true if zlib isn't current compression dev
> > */
> > +	enum overflow_test overflow = test_data->overflow;
> > +
> > +	/* from int_data: */
> > +	const char * const *test_bufs = int_data->test_bufs;
> > +
> > +	if (out_of_space_and_zlib)
> > +		data_size = OUT_OF_SPACE_BUF;
> > +	else {
> > +		if (ops_processed == NULL) {
> > +
> > +			not_zlib_compr = (test_data->zlib_dir ==
> > ZLIB_DECOMPRESS
> > +				|| test_data->zlib_dir == ZLIB_NONE);
> > +
> > +			ratio = (not_zlib_compr &&
> > +				(overflow == OVERFLOW_ENABLED)) ?
> > +				COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
> > +				COMPRESS_BUF_SIZE_RATIO;
[Shally] Why this condition is not true in case of ZLIB compression? For zlib compression too it can overflow right in case of deflate uncompressed output?!

> > +
> > +			data_size = strlen(test_bufs[i]) * ratio;
> > +
> > +		} else {
> > +			priv_data = (struct priv_op_data *)
> > +					(ops_processed[i] + 1);
> > +			data_size = strlen(test_bufs[priv_data->orig_idx]) +
> > 1;
> > +		}
> > +	}
> > +
> > +	return data_size;
[Shally] On the other hand, I don't see reason why it should return 0 unless object priv data is corrupted or not updated with test buf size, which ideally should not be the case. 
Given that, it can  be just updated that func returns expected output buffer size.


> > +}
> > +
> > +
> > +/**
> > + * Memory buffers preparation (for both compression and
> decompression).
> > + *
> > + * Memory allocation for comp/decomp buffers from mempool,
> depending
> > on
[Shally] can be reworded " function allocate output buffer depending on op_type : compression / decompression

> > + * ops_processed value. Developer is requested to provide input params
> > + * according to the following rule:
> > + *      if ops_processed == NULL -> current_bufs = comp_bufs[]
> > + *      if ops_processed != NULL -> current_bufs = decomp_bufs[]
> > + * -1 returned if function fail, without modifying the mbuf.
> > + *
[Shally] Same feedback here. This can be made simpler by adding another op_type in arg or getting this info from test args.

> > + * @param ops_processed
> > + *   Operations created as a result of compression phase. Should be
> > + *   set to NULL for compression
> > + * @param current_bufs
> > + *   mbufs being prepared in the function.
> > + * @param out_of_space_and_zlib
> > + *   Boolean value to switch into "out of space" buffer if set.
> > + *   To test "out-of-space" data size, zlib_decompress must be set as well.
> > + * @param int_data
> > + *   Interim data containing session/transformation objects.
> > + * @param test_data
> > + *   The test parameters set by users (command line parameters).
> > + * @param current_extbuf_info,
> > + *   The structure containing all the information related to external mbufs
> > + * @param current_memzone
> > + *   memzone used by external buffers
[Shally] add "valid if current_extbuf_info is set

> > + * @return
> > + *   - 0: On success.
> > + *   - -1: On error.
> > + */
> > +static int
> > +test_mbufs_destination_preparation(
> > +		struct rte_comp_op *ops_processed[], /*can be equal to
> > NULL*/
> > +		struct rte_mbuf *current_bufs[],
> > +		unsigned int out_of_space_and_zlib,
> > +		const struct interim_data_params *int_data,
> > +		const struct test_data_params *test_data,
> > +		struct rte_mbuf_ext_shared_info *current_extbuf_info,
> > +		const struct rte_memzone *current_memzone) {

[Shally] I would still recommend to make it part of priv array and keep prototype simpler to read

...
> > +/**
> > + * The main compression function.
> > + *
> > + * Operation(s) configuration, depending on CLI parameters.
> > + * Operation(s) processing.
> > + * -1 returned if function fail.
> > + *
> > + * @param int_data
> > + *   Interim data containing session/transformation objects.
> > + * @param test_data
> > + *   The test parameters set by users (command line parameters).
> > + * @param priv_arrays
> > + *   A container used for aggregation all the private test arrays.
> > + * @return
> > + *   - 0: On success.
> > + *   - -1: On error.
> > + */
...

> > +/**
> > + * The main decompression function.
[Shally] add more description : function perform decompression op 

> > + *
> > + * Operation(s) configuration, depending on CLI parameters.
> > + * Operation(s) processing.
> > + * -1 returned if function fail.
> > + *
[Shally] Not needed here.. @return also mention same

> > + * @param int_data
> > + *   Interim data containing session/transformation objects.
> > + * @param test_data
> > + *   The test parameters set by users (command line parameters).
> > + * @param priv_arrays
> > + *   A container used for aggregation all the private test arrays.
> > + * @return
> > + *   - 0: On success.
> > + *   - -1: On error.
> > + */
> > +static int
> > +test_deflate_decomp_run(const struct interim_data_params *int_data,
> > +		const struct test_data_params *test_data,
> > +		struct test_private_arrays *priv_arrays) {
> >
....

> > +/**
> > + * Compresses and decompresses input stream with compressdev API
> and
> > +Zlib API
> > + *
> > + * Basic test function. Common for all the functional tests.
> > + * -1 returned if function fail.
[Shally] Not needed here

> > + *
> > + * @param int_data
> > + *   Interim data containing session/transformation objects.
> > + * @param test_data
> > + *   The test parameters set by users (command line parameters).
> > + * @return
> > + *   - 1: Some operation not supported
> > + *   - 0: On success.
> > + *   - -1: On error.
> > + */
> > +
...

> > +	capa = rte_compressdev_capability_get(0,
> > RTE_COMP_ALGO_DEFLATE);
> > +	if (capa == NULL) {
> > +		RTE_LOG(ERR, USER1,
> > +			"Compress device does not support DEFLATE\n");
> > +		return -1;
> > +	}
> > +	test_objects_init(&priv_arrays, num_bufs);
> Do we need this? Why we just cant call source_prep API? That will also setup
> uncompressed_bufs
> [Artur] This is my approach. Do you prefer to have arrays initialisation moved
> to test_mbufs_source_preparation?
> If "yes", test_objects_init will be removed from the code.
[Shally] Ya. We can minimize code bit here.

> 
> > +
> > +	/* Prepare the source mbufs with the data */
> > +	ret = test_mbufs_source_preparation(int_data, test_data,
> > &priv_arrays);
> For code readability sake, it could test_setup_uncom_bufs()
> [Artur] Good idea. Would it be ok if I change:
> 1. test_mbufs_destination_preparation  into test_setup_uncom_bufs
> 2. test_mbufs_source_preparation into test_setup_com_bufs
> 
[Shally] Ya that look better or we can say , setup_input_bufs , setup_output_bufs .. just few suggestios

...
> > +/* COMPRESSION  */
> > +
> > +	/* Prepare the destination mbufs */
> > +	ret = test_mbufs_destination_preparation(
> Why we cant keep this prototype same as source_preparation() API for
> better readability?
> I mean we can pass priv_arry here too...
> [Artur] To get better readability it has been implemented in this way. That
> was only my point of view but I don't mind to modify the code according to
> your suggestion. It's also ok.
> 
[Shally] Ya. I would prefer 

> > +			NULL, /*can be equal to NULL*/
> > +			comp_bufs,
> > +			out_of_space == 1 && !zlib_compress,
> > +			int_data,
> > +			test_data,
> > +			&compbuf_info,
> > +			test_data->compbuf_memzone);
> > +	if (ret < 0) {
> > +		ret_status = -1;
> > +		goto exit;
> > +	}
> > +
...

> > 2.17.1

Re: [dpdk-dev] [EXT] [PATCH v3 1/1] test/compress: unit tests refactoring

[Akhil Goyal]

Hi Artur,

> > > ----------------------------------------------------------------------
> > > Core engine refactoring (test_deflate_comp_decomp function).
> > > Smaller specialized functions created.
> > >
> > > Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
> > > ---
Could you please close these comments by today?
For subtrees today is the last date for RC2

Regards,
Akhil

Re: [dpdk-dev] [EXT] [PATCH v3 1/1] test/compress: unit tests refactoring

[Trybula, ArturX]

> -----Original Message-----
> From: Trybula, ArturX <arturx.trybula@intel.com>
> Sent: Monday, November 4, 2019 3:55 PM
> To: Shally Verma <shallyv@marvell.com>; dev@dpdk.org; Trahe, Fiona 
> <fiona.trahe@intel.com>; Dybkowski, AdamX <adamx.dybkowski@intel.com>; 
> akhil.goyal@nxp.com
> Subject: RE: [EXT] [PATCH v3 1/1] test/compress: unit tests 
> refactoring
> 
> Hi Shally,
> 
> Please find my comments below.
> 
> > --------------------------------------------------------------------
> > -- Core engine refactoring (test_deflate_comp_decomp function).
> > Smaller specialized functions created.
> >
> > Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
> > ---
> >  app/test/test_compressdev.c            | 1118 +++++++++++++++++-------
> >  doc/guides/rel_notes/release_19_11.rst |    5 +
> >  2 files changed, 826 insertions(+), 297 deletions(-)
> >
.....
> > +static void
> > +test_objects_init(struct test_private_arrays *prv,
> > +		unsigned int num_bufs)
> > +{
> > +	/* Initialize all arrays to NULL */
> > +	memset(prv->uncomp_bufs, 0, sizeof(struct rte_mbuf *) *
> > num_bufs);
> > +	memset(prv->comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
> > +	memset(prv->ops, 0, sizeof(struct rte_comp_op *) * num_bufs);
> > +	memset(prv->ops_processed, 0, sizeof(struct rte_comp_op *) *
> > num_bufs);
> > +	memset(prv->priv_xforms, 0, sizeof(void *) * num_bufs);
> > +	memset(prv->compressed_data_size, 0, sizeof(uint32_t) *
> > num_bufs); }
> > +
> Does it really matter what pointer is pointing to? Sizeof(any pointer) 
> * num_bufs .. should be enough.
> [Artur] You are absolutely right that sizeof() of any pointer gives 
> the same result. But to be honest I don't understand your idea. Would 
> you like to have an extra variable to initialise all the pointer arrays?
> Eg:
> uint32_t array_size = sizeof(void *) * num_bufs; ...
> 	memset(prv->uncomp_bufs, 0, array_size);
> 	memset(prv->comp_bufs, 0, array_size); ...
[Shally] Hmm... ya that sort of. But my 2cents on it. So, its up to you .
[Artur] Ok, it will be modified according your suggestion.

> 
> 
> > +/**
> > + * Source buffers preparation (for compression).
> > + *
[Shally] Can we have more details here like: API that allocates input (and output buffers?) to perform compression operations?
[Artur] Ok, it will be modified according your suggestion.

> > + * Memory allocation for each buffer from mempool
> > + * -1 returned if function fail, without modifying the mbuf.
> > + *
> > + * @param int_data
[Shally] Can we change it to name test_params?
[Artur] Yes, we can.

> > + *   Interim data containing session/transformation objects.
> > + * @param test_data
> > + *   The test parameters set by users (command line parameters).
> > + * @param priv_arrays
[Shally] Can we change it to name test_priv_data?
[Artur] Yes, we can.

> > + *   A container used for aggregation all the private test arrays.
> > + * @return
> > + *   - 0: On success.
> > + *   - -1: On error.
> >   */
> >  static int
> > -test_deflate_comp_decomp(const struct interim_data_params *int_data,
> > -		const struct test_data_params *test_data)
> > +test_mbufs_source_preparation(const struct interim_data_params
> > *int_data,
> > +		const struct test_data_params *test_data,
> > +		const struct test_private_arrays *priv_arrays)
> >  {
....

> > +/**
> > + * Data size calculation (for both compression and decompression).
> > + *
[Shally] Can add more details here like calculate size of anticipated output buffer required for both compression and decompression operations based on input test_params.
Caller then allocate output buffer based on size returned by this function.
[Artur] Ok, it will be modified according your suggestion.

> > + * Developer is requested to provide input params
> > + * according to the following rule:
> > + *      if ops_processed == NULL -> compression
> > + *      if ops_processed != NULL -> decompression
[Shally] we are trying to  overload its purpose here. Can it be make simpler . we can use interim test param to check if op type is compression/decompression and then use op_processed[] on need basis
This will help in code readability else function looks complex to understand where as purpose is very simple.
[Artur] In some way it is not a perfect solution, but from my point of view it's very clear. 
There is no info in the interim test param (I suppose you meant interim_data_params) that could be useful in this case. There are pointers to xforms, but which one should I check? There must be some switch to choose the right flow. I can add another input param to the function, to indicate if it's a compress or decompress operation. But it seems to me, that it would be too much for this one case. Finally I can add another input param if you like this idea?

> > + * Values bigger than 0 have to be returned to avoid problems
> > + * with memory allocation
> > + *
[Shally] Can be reworded as " function return non-zero on success, 0 on failure. Caller should not allocate memory if 0. 
[Artur] Ok

> > + * @param ops_processed
> > + *   Operations created as a result of compression phase. Should be
> > + *   set to NULL for compression
> > + * @param out_of_space_and_zlib
> > + *   Boolean value to switch into "out of space" buffer if set.
> > + *   To test "out-of-space" data size, zlib_decompress must be set as well.
> > + * @param int_data
> > + *   Interim data containing session/transformation objects.
> > + * @param test_data
> > + *   The test parameters set by users (command line parameters).
> > + * @param i
> > + *   current buffer index
> > + * @return
> > + *   - values bigger than 0
> > + */
> > +static inline uint32_t
> > +test_mbufs_calculate_data_size(
> > +		struct rte_comp_op *ops_processed[], /*can be equal to
> > NULL*/
> > +		unsigned int out_of_space_and_zlib,
> > +		const struct interim_data_params *int_data,
> > +		const struct test_data_params *test_data,
> > +		unsigned int i)
> > +{
> > +	/* local variables: */
> > +	uint32_t data_size = 0;
> > +	struct priv_op_data *priv_data;
> > +	float ratio;
> > +	uint8_t not_zlib_compr; /* true if zlib isn't current compression dev
> > */
> > +	enum overflow_test overflow = test_data->overflow;
> > +
> > +	/* from int_data: */
> > +	const char * const *test_bufs = int_data->test_bufs;
> > +
> > +	if (out_of_space_and_zlib)
> > +		data_size = OUT_OF_SPACE_BUF;
> > +	else {
> > +		if (ops_processed == NULL) {
> > +
> > +			not_zlib_compr = (test_data->zlib_dir ==
> > ZLIB_DECOMPRESS
> > +				|| test_data->zlib_dir == ZLIB_NONE);
> > +
> > +			ratio = (not_zlib_compr &&
> > +				(overflow == OVERFLOW_ENABLED)) ?
> > +				COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
> > +				COMPRESS_BUF_SIZE_RATIO;
[Shally] Why this condition is not true in case of ZLIB compression? For zlib compression too it can overflow right in case of deflate uncompressed output?!
[Artur] I discussed this question with Fiona. The test was design for QAT and other tools like QAT. In this case Zlib is used just for a verification if the compression using QAT was correct. This condition should be preserved.

> > +
> > +			data_size = strlen(test_bufs[i]) * ratio;
> > +
> > +		} else {
> > +			priv_data = (struct priv_op_data *)
> > +					(ops_processed[i] + 1);
> > +			data_size = strlen(test_bufs[priv_data->orig_idx]) +
> > 1;
> > +		}
> > +	}
> > +
> > +	return data_size;
[Shally] On the other hand, I don't see reason why it should return 0 unless object priv data is corrupted or not updated with test buf size, which ideally should not be the case. 
Given that, it can  be just updated that func returns expected output buffer size.
[Artur] I don't see any reason why priv data could be corrupted. It would be a bigger problem if it happened.
All the cases are covered and the return value must be correct. If ops_processed is not NULL than priv_data has to be correct or we have a problem with QAT PMD. Verification if the filed orig_idx is correct is even more complicated. From my perspective mentioned verification shouldn't be considered as a part of this function. It's too late.
Another input param discussed below: op_type?
 
> > +}
> > +
> > +
> > +/**
> > + * Memory buffers preparation (for both compression and
> decompression).
> > + *
> > + * Memory allocation for comp/decomp buffers from mempool,
> depending
> > on
[Shally] can be reworded " function allocate output buffer depending on op_type : compression / decompression
[Artur] Ok

> > + * ops_processed value. Developer is requested to provide input params
> > + * according to the following rule:
> > + *      if ops_processed == NULL -> current_bufs = comp_bufs[]
> > + *      if ops_processed != NULL -> current_bufs = decomp_bufs[]
> > + * -1 returned if function fail, without modifying the mbuf.
> > + *
[Shally] Same feedback here. This can be made simpler by adding another op_type in arg or getting this info from test args.
[Artur] Similar issue was discussed above. So let's do both cases in the same way. I'm going to define another enum. It will be an extra input param of these functions:
1. test_mbufs_calculate_data_size
2. test_mbufs_destination_preparation
Is it ok for you?


> > + * @param ops_processed
> > + *   Operations created as a result of compression phase. Should be
> > + *   set to NULL for compression
> > + * @param current_bufs
> > + *   mbufs being prepared in the function.
> > + * @param out_of_space_and_zlib
> > + *   Boolean value to switch into "out of space" buffer if set.
> > + *   To test "out-of-space" data size, zlib_decompress must be set as well.
> > + * @param int_data
> > + *   Interim data containing session/transformation objects.
> > + * @param test_data
> > + *   The test parameters set by users (command line parameters).
> > + * @param current_extbuf_info,
> > + *   The structure containing all the information related to external mbufs
> > + * @param current_memzone
> > + *   memzone used by external buffers
[Shally] add "valid if current_extbuf_info is set
[Artur] Ok

> > + * @return
> > + *   - 0: On success.
> > + *   - -1: On error.
> > + */
> > +static int
> > +test_mbufs_destination_preparation(
> > +		struct rte_comp_op *ops_processed[], /*can be equal to
> > NULL*/
> > +		struct rte_mbuf *current_bufs[],
> > +		unsigned int out_of_space_and_zlib,
> > +		const struct interim_data_params *int_data,
> > +		const struct test_data_params *test_data,
> > +		struct rte_mbuf_ext_shared_info *current_extbuf_info,
> > +		const struct rte_memzone *current_memzone) {

[Shally] I would still recommend to make it part of priv array and keep prototype simpler to read
[Artur] What object do you mean precisely?

...
> > +/**
> > + * The main compression function.
> > + *
> > + * Operation(s) configuration, depending on CLI parameters.
> > + * Operation(s) processing.
> > + * -1 returned if function fail.
> > + *
> > + * @param int_data
> > + *   Interim data containing session/transformation objects.
> > + * @param test_data
> > + *   The test parameters set by users (command line parameters).
> > + * @param priv_arrays
> > + *   A container used for aggregation all the private test arrays.
> > + * @return
> > + *   - 0: On success.
> > + *   - -1: On error.
> > + */
...

> > +/**
> > + * The main decompression function.
[Shally] add more description : function perform decompression op 
[Artur] Ok

> > + *
> > + * Operation(s) configuration, depending on CLI parameters.
> > + * Operation(s) processing.
> > + * -1 returned if function fail.
> > + *
[Shally] Not needed here.. @return also mention same
[Artur] Ok

> > + * @param int_data
> > + *   Interim data containing session/transformation objects.
> > + * @param test_data
> > + *   The test parameters set by users (command line parameters).
> > + * @param priv_arrays
> > + *   A container used for aggregation all the private test arrays.
> > + * @return
> > + *   - 0: On success.
> > + *   - -1: On error.
> > + */
> > +static int
> > +test_deflate_decomp_run(const struct interim_data_params *int_data,
> > +		const struct test_data_params *test_data,
> > +		struct test_private_arrays *priv_arrays) {
> >
....

> > +/**
> > + * Compresses and decompresses input stream with compressdev API
> and
> > +Zlib API
> > + *
> > + * Basic test function. Common for all the functional tests.
> > + * -1 returned if function fail.
[Shally] Not needed here
[Artur] Ok

> > + *
> > + * @param int_data
> > + *   Interim data containing session/transformation objects.
> > + * @param test_data
> > + *   The test parameters set by users (command line parameters).
> > + * @return
> > + *   - 1: Some operation not supported
> > + *   - 0: On success.
> > + *   - -1: On error.
> > + */
> > +
...

> > +	capa = rte_compressdev_capability_get(0,
> > RTE_COMP_ALGO_DEFLATE);
> > +	if (capa == NULL) {
> > +		RTE_LOG(ERR, USER1,
> > +			"Compress device does not support DEFLATE\n");
> > +		return -1;
> > +	}
> > +	test_objects_init(&priv_arrays, num_bufs);
> Do we need this? Why we just cant call source_prep API? That will also setup
> uncompressed_bufs
> [Artur] This is my approach. Do you prefer to have arrays initialisation moved
> to test_mbufs_source_preparation?
> If "yes", test_objects_init will be removed from the code.
[Shally] Ya. We can minimize code bit here.
[Artur] Ok

> 
> > +
> > +	/* Prepare the source mbufs with the data */
> > +	ret = test_mbufs_source_preparation(int_data, test_data,
> > &priv_arrays);
> For code readability sake, it could test_setup_uncom_bufs()
> [Artur] Good idea. Would it be ok if I change:
> 1. test_mbufs_destination_preparation  into test_setup_uncom_bufs
> 2. test_mbufs_source_preparation into test_setup_com_bufs
> 
[Shally] Ya that look better or we can say , setup_input_bufs , setup_output_bufs .. just few suggestios
[Artur] Ok

...
> > +/* COMPRESSION  */
> > +
> > +	/* Prepare the destination mbufs */
> > +	ret = test_mbufs_destination_preparation(
> Why we cant keep this prototype same as source_preparation() API for
> better readability?
> I mean we can pass priv_arry here too...
> [Artur] To get better readability it has been implemented in this way. That
> was only my point of view but I don't mind to modify the code according to
> your suggestion. It's also ok.
> 
[Shally] Ya. I would prefer 
[Artur] Ok

> > +			NULL, /*can be equal to NULL*/
> > +			comp_bufs,
> > +			out_of_space == 1 && !zlib_compress,
> > +			int_data,
> > +			test_data,
> > +			&compbuf_info,
> > +			test_data->compbuf_memzone);
> > +	if (ret < 0) {
> > +		ret_status = -1;
> > +		goto exit;
> > +	}
> > +
...

> > 2.17.1

Re: [dpdk-dev] [EXT] [PATCH v3 1/1] test/compress: unit tests refactoring

[Shally Verma]

> -----Original Message-----
> From: Trybula, ArturX <arturx.trybula@intel.com>
> Sent: Wednesday, November 6, 2019 5:03 PM
> To: Shally Verma <shallyv@marvell.com>; dev@dpdk.org; Trahe, Fiona
> <fiona.trahe@intel.com>; Dybkowski, AdamX
> <adamx.dybkowski@intel.com>; akhil.goyal@nxp.com; Ashish Gupta
> <ashishg@marvell.com>
> Subject: RE: [EXT] [PATCH v3 1/1] test/compress: unit tests refactoring
> 
> 
> > -----Original Message-----
> > From: Trybula, ArturX <arturx.trybula@intel.com>
> > Sent: Monday, November 4, 2019 3:55 PM
> > To: Shally Verma <shallyv@marvell.com>; dev@dpdk.org; Trahe, Fiona
> > <fiona.trahe@intel.com>; Dybkowski, AdamX
> <adamx.dybkowski@intel.com>;
> > akhil.goyal@nxp.com
> > Subject: RE: [EXT] [PATCH v3 1/1] test/compress: unit tests
> > refactoring
> >
> > Hi Shally,
> >
> > Please find my comments below.
> >
> > > --------------------------------------------------------------------
> > > -- Core engine refactoring (test_deflate_comp_decomp function).
> > > Smaller specialized functions created.
> > >
> > > Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
> > > ---
> > >  app/test/test_compressdev.c            | 1118 +++++++++++++++++-------
> > >  doc/guides/rel_notes/release_19_11.rst |    5 +
> > >  2 files changed, 826 insertions(+), 297 deletions(-)
> > >
> .....
...

> >
...
> > > + * Developer is requested to provide input params
> > > + * according to the following rule:
> > > + *      if ops_processed == NULL -> compression
> > > + *      if ops_processed != NULL -> decompression
> [Shally] we are trying to  overload its purpose here. Can it be make simpler .
> we can use interim test param to check if op type is
> compression/decompression and then use op_processed[] on need basis
> This will help in code readability else function looks complex to understand
> where as purpose is very simple.
> [Artur] In some way it is not a perfect solution, but from my point of view it's
> very clear.
> There is no info in the interim test param (I suppose you meant
> interim_data_params) that could be useful in this case. There are pointers to
> xforms, but which one should I check? There must be some switch to choose
> the right flow. I can add another input param to the function, to indicate if it's
> a compress or decompress operation. But it seems to me, that it would be
> too much for this one case. Finally I can add another input param if you like
> this idea?
> 


[Shally] Believe you agreed below that you'll add an param op_type?

...

> > > +	else {
> > > +		if (ops_processed == NULL) {
> > > +
> > > +			not_zlib_compr = (test_data->zlib_dir ==
> > > ZLIB_DECOMPRESS
> > > +				|| test_data->zlib_dir == ZLIB_NONE);
> > > +
> > > +			ratio = (not_zlib_compr &&
> > > +				(overflow == OVERFLOW_ENABLED)) ?
> > > +				COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
> > > +				COMPRESS_BUF_SIZE_RATIO;
> [Shally] Why this condition is not true in case of ZLIB compression? For zlib
> compression too it can overflow right in case of deflate uncompressed
> output?!
> [Artur] I discussed this question with Fiona. The test was design for QAT and
> other tools like QAT. In this case Zlib is used just for a verification if the
> compression using QAT was correct. This condition should be preserved.
> 
[Shally] ohh ok I noticed not_zlib_compr means zlib will decompress. I thought it otherwise. So ignore my feedback.

> > > +
> > > +			data_size = strlen(test_bufs[i]) * ratio;
> > > +
> > > +		} else {
> > > +			priv_data = (struct priv_op_data *)
> > > +					(ops_processed[i] + 1);
> > > +			data_size = strlen(test_bufs[priv_data->orig_idx]) +
> > > 1;
> > > +		}
> > > +	}
> > > +
> > > +	return data_size;
> [Shally] On the other hand, I don't see reason why it should return 0 unless
> object priv data is corrupted or not updated with test buf size, which ideally
> should not be the case.
> Given that, it can  be just updated that func returns expected output buffer
> size.
> [Artur] I don't see any reason why priv data could be corrupted. It would be a
> bigger problem if it happened.
> All the cases are covered and the return value must be correct. If
> ops_processed is not NULL than priv_data has to be correct or we have a
> problem with QAT PMD. Verification if the filed orig_idx is correct is even
> more complicated. From my perspective mentioned verification shouldn't be
> considered as a part of this function. It's too late.

[Shally] I think we are on same page here. I meant same thing that I don't see reason why func should return 0. It will always return some non-zero value. So my point was value 0 seems redundant here.

> Another input param discussed below: op_type?
> 
> > > +}
> > > +
> > > +
> > > +/**
> > > + * Memory buffers preparation (for both compression and
> > decompression).
> > > + *
> > > + * Memory allocation for comp/decomp buffers from mempool,
> > depending
> > > on
> [Shally] can be reworded " function allocate output buffer depending on
> op_type : compression / decompression [Artur] Ok
> 
> > > + * ops_processed value. Developer is requested to provide input
> > > + params
> > > + * according to the following rule:
> > > + *      if ops_processed == NULL -> current_bufs = comp_bufs[]
> > > + *      if ops_processed != NULL -> current_bufs = decomp_bufs[]
> > > + * -1 returned if function fail, without modifying the mbuf.
> > > + *
> [Shally] Same feedback here. This can be made simpler by adding another
> op_type in arg or getting this info from test args.
> [Artur] Similar issue was discussed above. So let's do both cases in the same
> way. I'm going to define another enum. It will be an extra input param of
> these functions:
> 1. test_mbufs_calculate_data_size
> 2. test_mbufs_destination_preparation
> Is it ok for you?
> 
[Shally] Ok

> 
...

> > > + * @return
> > > + *   - 0: On success.
> > > + *   - -1: On error.
> > > + */
> > > +static int
> > > +test_mbufs_destination_preparation(
> > > +		struct rte_comp_op *ops_processed[], /*can be equal to
> > > NULL*/
> > > +		struct rte_mbuf *current_bufs[],
> > > +		unsigned int out_of_space_and_zlib,
> > > +		const struct interim_data_params *int_data,
> > > +		const struct test_data_params *test_data,
> > > +		struct rte_mbuf_ext_shared_info *current_extbuf_info,
> > > +		const struct rte_memzone *current_memzone) {
> 
> [Shally] I would still recommend to make it part of priv array and keep
> prototype simpler to read [Artur] What object do you mean precisely?
> 
My suggestion was to move extbuf_info, out_of_space_zlib too to priv_data .. but its just suggestion... you can ignore If it complicate the purpose

> ...
...
> > > 2.17.1

Re: [dpdk-dev] [EXT] [PATCH v3 1/1] test/compress: unit tests refactoring

[Trybula, ArturX]

> 
> 
> > -----Original Message-----
> > From: Trybula, ArturX <arturx.trybula@intel.com>
> > Sent: Monday, November 4, 2019 3:55 PM
> > To: Shally Verma <shallyv@marvell.com>; dev@dpdk.org; Trahe, Fiona 
> > <fiona.trahe@intel.com>; Dybkowski, AdamX
> <adamx.dybkowski@intel.com>;
> > akhil.goyal@nxp.com
> > Subject: RE: [EXT] [PATCH v3 1/1] test/compress: unit tests 
> > refactoring
> >
> > Hi Shally,
> >
> > Please find my comments below.
> >
> > > ------------------------------------------------------------------
> > > --
> > > -- Core engine refactoring (test_deflate_comp_decomp function).
> > > Smaller specialized functions created.
> > >
> > > Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
> > > ---
> > >  app/test/test_compressdev.c            | 1118 +++++++++++++++++-------
> > >  doc/guides/rel_notes/release_19_11.rst |    5 +
> > >  2 files changed, 826 insertions(+), 297 deletions(-)
> > >
> .....
...

> >
...
> > > + * Developer is requested to provide input params
> > > + * according to the following rule:
> > > + *      if ops_processed == NULL -> compression
> > > + *      if ops_processed != NULL -> decompression
> [Shally] we are trying to  overload its purpose here. Can it be make simpler .
> we can use interim test param to check if op type is 
> compression/decompression and then use op_processed[] on need basis 
> This will help in code readability else function looks complex to 
> understand where as purpose is very simple.
> [Artur] In some way it is not a perfect solution, but from my point of 
> view it's very clear.
> There is no info in the interim test param (I suppose you meant
> interim_data_params) that could be useful in this case. There are 
> pointers to xforms, but which one should I check? There must be some 
> switch to choose the right flow. I can add another input param to the 
> function, to indicate if it's a compress or decompress operation. But 
> it seems to me, that it would be too much for this one case. Finally I 
> can add another input param if you like this idea?
> 


[Shally] Believe you agreed below that you'll add an param op_type?
[Artur] Yes, this is what we agreed.

...

> > > +	else {
> > > +		if (ops_processed == NULL) {
> > > +
> > > +			not_zlib_compr = (test_data->zlib_dir ==
> > > ZLIB_DECOMPRESS
> > > +				|| test_data->zlib_dir == ZLIB_NONE);
> > > +
> > > +			ratio = (not_zlib_compr &&
> > > +				(overflow == OVERFLOW_ENABLED)) ?
> > > +				COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
> > > +				COMPRESS_BUF_SIZE_RATIO;
> [Shally] Why this condition is not true in case of ZLIB compression? 
> For zlib compression too it can overflow right in case of deflate 
> uncompressed output?!
> [Artur] I discussed this question with Fiona. The test was design for 
> QAT and other tools like QAT. In this case Zlib is used just for a 
> verification if the compression using QAT was correct. This condition should be preserved.
> 
[Shally] ohh ok I noticed not_zlib_compr means zlib will decompress. I thought it otherwise. So ignore my feedback.
[Artur] Ok

> > > +
> > > +			data_size = strlen(test_bufs[i]) * ratio;
> > > +
> > > +		} else {
> > > +			priv_data = (struct priv_op_data *)
> > > +					(ops_processed[i] + 1);
> > > +			data_size = strlen(test_bufs[priv_data->orig_idx]) +
> > > 1;
> > > +		}
> > > +	}
> > > +
> > > +	return data_size;
> [Shally] On the other hand, I don't see reason why it should return 0 
> unless object priv data is corrupted or not updated with test buf 
> size, which ideally should not be the case.
> Given that, it can  be just updated that func returns expected output 
> buffer size.
> [Artur] I don't see any reason why priv data could be corrupted. It 
> would be a bigger problem if it happened.
> All the cases are covered and the return value must be correct. If 
> ops_processed is not NULL than priv_data has to be correct or we have 
> a problem with QAT PMD. Verification if the filed orig_idx is correct 
> is even more complicated. From my perspective mentioned verification 
> shouldn't be considered as a part of this function. It's too late.

[Shally] I think we are on same page here. I meant same thing that I don't see reason why func should return 0. It will always return some non-zero value. So my point was value 0 seems redundant here.
[Artur] Ok, I see your point. It's true that initialization is not necessary. Will be corrected.

> Another input param discussed below: op_type?
> 
> > > +}
> > > +
> > > +
> > > +/**
> > > + * Memory buffers preparation (for both compression and
> > decompression).
> > > + *
> > > + * Memory allocation for comp/decomp buffers from mempool,
> > depending
> > > on
> [Shally] can be reworded " function allocate output buffer depending 
> on op_type : compression / decompression [Artur] Ok
> 
> > > + * ops_processed value. Developer is requested to provide input 
> > > + params
> > > + * according to the following rule:
> > > + *      if ops_processed == NULL -> current_bufs = comp_bufs[]
> > > + *      if ops_processed != NULL -> current_bufs = decomp_bufs[]
> > > + * -1 returned if function fail, without modifying the mbuf.
> > > + *
> [Shally] Same feedback here. This can be made simpler by adding 
> another op_type in arg or getting this info from test args.
> [Artur] Similar issue was discussed above. So let's do both cases in 
> the same way. I'm going to define another enum. It will be an extra 
> input param of these functions:
> 1. test_mbufs_calculate_data_size
> 2. test_mbufs_destination_preparation
> Is it ok for you?
> 
[Shally] Ok

> 
...

> > > + * @return
> > > + *   - 0: On success.
> > > + *   - -1: On error.
> > > + */
> > > +static int
> > > +test_mbufs_destination_preparation(
> > > +		struct rte_comp_op *ops_processed[], /*can be equal to
> > > NULL*/
> > > +		struct rte_mbuf *current_bufs[],
> > > +		unsigned int out_of_space_and_zlib,
> > > +		const struct interim_data_params *int_data,
> > > +		const struct test_data_params *test_data,
> > > +		struct rte_mbuf_ext_shared_info *current_extbuf_info,
> > > +		const struct rte_memzone *current_memzone) {
> 
> [Shally] I would still recommend to make it part of priv array and 
> keep prototype simpler to read [Artur] What object do you mean precisely?
> 
My suggestion was to move extbuf_info, out_of_space_zlib too to priv_data .. but its just suggestion... you can ignore If it complicate the purpose
[Artur] Ok. I'll try to optimize the list of params. 

[Artur] Shally, I assume all the issues can be closed and V4 can be prepared tomorrow?

> ...
...
> > > 2.17.1

Re: [dpdk-dev] [EXT] [PATCH v3 1/1] test/compress: unit tests refactoring

[Shally Verma]

> -----Original Message-----
> From: Trybula, ArturX <arturx.trybula@intel.com>
> Sent: Wednesday, November 6, 2019 9:03 PM
> To: Shally Verma <shallyv@marvell.com>; dev@dpdk.org; Trahe, Fiona
> <fiona.trahe@intel.com>; Dybkowski, AdamX
> <adamx.dybkowski@intel.com>; akhil.goyal@nxp.com; Ashish Gupta
> <ashishg@marvell.com>
> Subject: RE: [EXT] [PATCH v3 1/1] test/compress: unit tests refactoring
> 
..
> My suggestion was to move extbuf_info, out_of_space_zlib too to priv_data
> .. but its just suggestion... you can ignore If it complicate the purpose [Artur]
> Ok. I'll try to optimize the list of params.
> 
> [Artur] Shally, I assume all the issues can be closed and V4 can be prepared
> tomorrow?
> 
[Shally] Yes.

> > ...
> ...
> > > > 2.17.1

[dpdk-dev] [PATCH v4 0/1] compression: unit tests refactoring

[Artur Trybula]

v4 changes:
	- rebase onto the recent master
	- API modification according to the reviewer suggestions
	- additional modifications after code review (functions
	  descriptions, variables renaming, small logic modification)

v3 changes:
	- rebase onto the recent master
	- small modifications after code review
	- additional function extracted for data size calculation
	  (test_mbufs_calculate_data_size)

v2 changes:
	- unnecessary "printf" removed from the code

Signed-off-by: Artur Trybula <arturx.trybula@intel.com>

Artur Trybula (1):
  test/compress: unit tests refactoring

 app/test/test_compressdev.c            | 1111 +++++++++++++++++-------
 doc/guides/rel_notes/release_19_11.rst |    5 +
 2 files changed, 821 insertions(+), 295 deletions(-)

-- 
2.17.1

[dpdk-dev] [PATCH v4 1/1] test/compress: unit tests refactoring

[Artur Trybula]

Core engine refactoring (test_deflate_comp_decomp function).
Smaller specialized functions created.

Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
Acked-by: Adam Dybkowski <adamx.dybkowski@intel.com>
---
 app/test/test_compressdev.c            | 1111 +++++++++++++++++-------
 doc/guides/rel_notes/release_19_11.rst |    5 +
 2 files changed, 821 insertions(+), 295 deletions(-)

diff --git a/app/test/test_compressdev.c b/app/test/test_compressdev.c
index 283c64971..4b1084cae 100644
--- a/app/test/test_compressdev.c
+++ b/app/test/test_compressdev.c
@@ -78,6 +78,11 @@ enum overflow_test {
 	OVERFLOW_ENABLED
 };
 
+enum operation_type {
+	OPERATION_COMPRESSION,
+	OPERATION_DECOMPRESSION
+};
+
 struct priv_op_data {
 	uint16_t orig_idx;
 };
@@ -120,6 +125,20 @@ struct test_data_params {
 	enum overflow_test overflow;
 };
 
+struct test_private_arrays {
+	struct rte_mbuf **uncomp_bufs;
+	struct rte_mbuf **comp_bufs;
+	struct rte_comp_op **ops;
+	struct rte_comp_op **ops_processed;
+	void **priv_xforms;
+	uint64_t *compress_checksum;
+	uint32_t *compressed_data_size;
+	void **stream;
+	char **all_decomp_data;
+	unsigned int *decomp_produced_data_size;
+	uint16_t num_priv_xforms;
+};
+
 static struct comp_testsuite_params testsuite_params = { 0 };
 
 static void
@@ -662,6 +681,7 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf,
 		data_size = remaining_data;
 	else
 		data_size = seg_size;
+
 	buf_ptr = rte_pktmbuf_append(head_buf, data_size);
 	if (buf_ptr == NULL) {
 		RTE_LOG(ERR, USER1,
@@ -734,8 +754,9 @@ extbuf_free_callback(void *addr __rte_unused, void *opaque __rte_unused)
 }
 
 static int
-test_run_enqueue_dequeue(struct rte_comp_op **ops, unsigned int num_bufs,
-		  struct rte_comp_op **ops_processed)
+test_run_enqueue_dequeue(struct rte_comp_op **ops,
+			 struct rte_comp_op **ops_processed,
+			 unsigned int num_bufs)
 {
 	uint16_t num_enqd, num_deqd, num_total_deqd;
 	unsigned int deqd_retries = 0;
@@ -776,81 +797,64 @@ test_run_enqueue_dequeue(struct rte_comp_op **ops, unsigned int num_bufs,
 	return 0;
 }
 
-/*
- * Compresses and decompresses buffer with compressdev API and Zlib API
+/**
+ * Arrays initialization. Input buffers preparation for compression.
+ *
+ * API that initializes all the private arrays to NULL
+ * and allocates input buffers to perform compression operations.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param test_priv_data
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
  */
 static int
-test_deflate_comp_decomp(const struct interim_data_params *int_data,
-		const struct test_data_params *test_data)
+test_setup_com_bufs(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *test_priv_data)
 {
+	/* local variables: */
+	unsigned int i;
+	uint32_t data_size;
+	char *buf_ptr;
+	int ret;
+	char **all_decomp_data = test_priv_data->all_decomp_data;
+
 	struct comp_testsuite_params *ts_params = &testsuite_params;
+
+	/* from int_data: */
 	const char * const *test_bufs = int_data->test_bufs;
 	unsigned int num_bufs = int_data->num_bufs;
-	uint16_t *buf_idx = int_data->buf_idx;
-	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
-	struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms;
-	unsigned int num_xforms = int_data->num_xforms;
-	enum rte_comp_op_type compress_state = test_data->compress_state;
-	enum rte_comp_op_type decompress_state = test_data->decompress_state;
+
+	/* from test_data: */
 	unsigned int buff_type = test_data->buff_type;
-	unsigned int out_of_space = test_data->out_of_space;
 	unsigned int big_data = test_data->big_data;
-	enum zlib_direction zlib_dir = test_data->zlib_dir;
-	enum overflow_test overflow_tst = test_data->overflow;
-	int ret_status = TEST_FAILED;
-	struct rte_mbuf_ext_shared_info inbuf_info;
-	struct rte_mbuf_ext_shared_info compbuf_info;
-	struct rte_mbuf_ext_shared_info decompbuf_info;
-	int ret;
-	struct rte_mbuf *uncomp_bufs[num_bufs];
-	struct rte_mbuf *comp_bufs[num_bufs];
-	struct rte_comp_op *ops[num_bufs];
-	struct rte_comp_op *ops_processed[num_bufs];
-	void *priv_xforms[num_bufs];
-	uint16_t num_enqd, num_deqd, num_total_deqd;
-	uint16_t num_priv_xforms = 0;
-	unsigned int deqd_retries = 0;
-	struct priv_op_data *priv_data;
-	char *buf_ptr;
-	unsigned int i;
+
+	/* from test_priv_data: */
+	struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
 	struct rte_mempool *buf_pool;
-	uint32_t data_size;
-	/* Compressing with CompressDev */
-	unsigned int oos_zlib_decompress =
-			(zlib_dir == ZLIB_NONE || zlib_dir == ZLIB_DECOMPRESS);
-	/* Decompressing with CompressDev */
-	unsigned int oos_zlib_compress =
-			(zlib_dir == ZLIB_NONE || zlib_dir == ZLIB_COMPRESS);
-	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];
-	uint32_t compressed_data_size[num_bufs];
-	void *stream = NULL;
-	char *all_decomp_data = NULL;
-	unsigned int decomp_produced_data_size = 0;
-	unsigned int step = 0;
 
-	TEST_ASSERT(decompress_state == RTE_COMP_OP_STATELESS || num_bufs == 1,
-		    "Number of stateful operations in a step should be 1");
+	static struct rte_mbuf_ext_shared_info inbuf_info;
 
-	if (capa == NULL) {
-		RTE_LOG(ERR, USER1,
-			"Compress device does not support DEFLATE\n");
-		return -ENOTSUP;
-	}
+	size_t array_size = sizeof(void *) * num_bufs;
 
 	/* Initialize all arrays to NULL */
-	memset(uncomp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
-	memset(comp_bufs, 0, sizeof(struct rte_mbuf *) * num_bufs);
-	memset(ops, 0, sizeof(struct rte_comp_op *) * num_bufs);
-	memset(ops_processed, 0, sizeof(struct rte_comp_op *) * num_bufs);
-	memset(priv_xforms, 0, sizeof(void *) * num_bufs);
-	memset(compressed_data_size, 0, sizeof(uint32_t) * num_bufs);
-
-	if (decompress_state == RTE_COMP_OP_STATEFUL) {
+	memset(test_priv_data->uncomp_bufs, 0, array_size);
+	memset(test_priv_data->comp_bufs, 0, array_size);
+	memset(test_priv_data->ops, 0, array_size);
+	memset(test_priv_data->ops_processed, 0, array_size);
+	memset(test_priv_data->priv_xforms, 0, array_size);
+	memset(test_priv_data->compressed_data_size,
+	       0, sizeof(uint32_t) * num_bufs);
+
+	if (test_data->decompress_state == RTE_COMP_OP_STATEFUL) {
 		data_size = strlen(test_bufs[0]) + 1;
-		all_decomp_data = rte_malloc(NULL, data_size,
+		*all_decomp_data = rte_malloc(NULL, data_size,
 					     RTE_CACHE_LINE_SIZE);
 	}
 
@@ -861,14 +865,15 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	else
 		buf_pool = ts_params->large_mbuf_pool;
 
-	/* Prepare the source mbufs with the data */
+	/* for compression uncomp_bufs is used as a source buffer */
+	/* allocation from buf_pool (mempool type) */
 	ret = rte_pktmbuf_alloc_bulk(buf_pool,
 				uncomp_bufs, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Source mbufs could not be allocated "
 			"from the mempool\n");
-		goto exit;
+		return -1;
 	}
 
 	if (test_data->use_external_mbufs) {
@@ -881,8 +886,13 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 					test_data->inbuf_memzone->iova,
 					test_data->inbuf_data_size,
 					&inbuf_info);
-			rte_pktmbuf_append(uncomp_bufs[i],
+			buf_ptr = rte_pktmbuf_append(uncomp_bufs[i],
 					test_data->inbuf_data_size);
+			if (buf_ptr == NULL) {
+				RTE_LOG(ERR, USER1,
+					"Append extra bytes to the source mbuf failed\n");
+				return -1;
+			}
 		}
 	} else if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
 		for (i = 0; i < num_bufs; i++) {
@@ -893,106 +903,302 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 			    big_data ? buf_pool : ts_params->large_mbuf_pool,
 			    big_data ? 0 : MAX_SEGS,
 			    big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE) < 0)
-				goto exit;
+				return -1;
 		}
 	} 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);
 			if (buf_ptr == NULL) {
 				RTE_LOG(ERR, USER1,
 					"Append extra bytes to the source mbuf failed\n");
-				goto exit;
+				return -1;
 			}
 			strlcpy(buf_ptr, test_bufs[i], data_size);
 		}
 	}
 
-	/* Prepare the destination mbufs */
-	ret = rte_pktmbuf_alloc_bulk(buf_pool, comp_bufs, num_bufs);
+	return 0;
+}
+
+/**
+ * Data size calculation (for both compression and decompression).
+ *
+ * Calculate size of anticipated output buffer required for both
+ * compression and decompression operations based on input int_data.
+ *
+ * @param op_type
+ *   Operation type: compress or decompress
+ * @param out_of_space_and_zlib
+ *   Boolean value to switch into "out of space" buffer if set.
+ *   To test "out-of-space" data size, zlib_decompress must be set as well.
+ * @param test_priv_data
+ *   A container used for aggregation all the private test arrays.
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param i
+ *   current buffer index
+ * @return
+ *   data size
+ */
+static inline uint32_t
+test_mbufs_calculate_data_size(
+		enum operation_type op_type,
+		unsigned int out_of_space_and_zlib,
+		const struct test_private_arrays *test_priv_data,
+		const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		unsigned int i)
+{
+	/* local variables: */
+	uint32_t data_size;
+	struct priv_op_data *priv_data;
+	float ratio;
+	uint8_t not_zlib_compr; /* true if zlib isn't current compression dev */
+	enum overflow_test overflow = test_data->overflow;
+
+	/* from test_priv_data: */
+	struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
+
+	/* from int_data: */
+	const char * const *test_bufs = int_data->test_bufs;
+
+	if (out_of_space_and_zlib)
+		data_size = OUT_OF_SPACE_BUF;
+	else {
+		if (op_type == OPERATION_COMPRESSION) {
+			not_zlib_compr = (test_data->zlib_dir == ZLIB_DECOMPRESS
+				|| test_data->zlib_dir == ZLIB_NONE);
+
+			ratio = (not_zlib_compr &&
+				(overflow == OVERFLOW_ENABLED)) ?
+				COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
+				COMPRESS_BUF_SIZE_RATIO;
+
+			data_size = strlen(test_bufs[i]) * ratio;
+
+		} else {
+			priv_data = (struct priv_op_data *)
+					(ops_processed[i] + 1);
+			data_size = strlen(test_bufs[priv_data->orig_idx]) + 1;
+		}
+	}
+
+	return data_size;
+}
+
+
+/**
+ * Memory buffers preparation (for both compression and decompression).
+ *
+ * Function allocates output buffers to perform compression
+ * or decompression operations depending on value of op_type.
+ *
+ * @param op_type
+ *   Operation type: compress or decompress
+ * @param out_of_space_and_zlib
+ *   Boolean value to switch into "out of space" buffer if set.
+ *   To test "out-of-space" data size, zlib_decompress must be set as well.
+ * @param test_priv_data
+ *   A container used for aggregation all the private test arrays.
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param current_extbuf_info,
+ *   The structure containing all the information related to external mbufs
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_setup_output_bufs(
+		enum operation_type op_type,
+		unsigned int out_of_space_and_zlib,
+		const struct test_private_arrays *test_priv_data,
+		const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		struct rte_mbuf_ext_shared_info *current_extbuf_info)
+{
+	/* local variables: */
+	unsigned int i;
+	uint32_t data_size;
+	int ret;
+	char *buf_ptr;
+
+	/* from test_priv_data: */
+	struct rte_mbuf **current_bufs;
+
+	/* from int_data: */
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from test_data: */
+	unsigned int buff_type = test_data->buff_type;
+	unsigned int big_data = test_data->big_data;
+	const struct rte_memzone *current_memzone;
+
+	struct comp_testsuite_params *ts_params = &testsuite_params;
+	struct rte_mempool *buf_pool;
+
+	if (big_data)
+		buf_pool = ts_params->big_mbuf_pool;
+	else if (buff_type == SGL_BOTH)
+		buf_pool = ts_params->small_mbuf_pool;
+	else
+		buf_pool = ts_params->large_mbuf_pool;
+
+	if (op_type == OPERATION_COMPRESSION)
+		current_bufs = test_priv_data->comp_bufs;
+	else
+		current_bufs = test_priv_data->uncomp_bufs;
+
+	/* the mbufs allocation*/
+	ret = rte_pktmbuf_alloc_bulk(buf_pool, current_bufs, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Destination mbufs could not be allocated "
 			"from the mempool\n");
-		goto exit;
+		return -1;
 	}
 
 	if (test_data->use_external_mbufs) {
-		compbuf_info.free_cb = extbuf_free_callback;
-		compbuf_info.fcb_opaque = NULL;
-		rte_mbuf_ext_refcnt_set(&compbuf_info, 1);
-		for (i = 0; i < num_bufs; i++) {
-			rte_pktmbuf_attach_extbuf(comp_bufs[i],
-					test_data->compbuf_memzone->addr,
-					test_data->compbuf_memzone->iova,
-					test_data->compbuf_memzone->len,
-					&compbuf_info);
-			rte_pktmbuf_append(comp_bufs[i],
-					test_data->compbuf_memzone->len);
-		}
-	} else if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
+		current_extbuf_info->free_cb = extbuf_free_callback;
+		current_extbuf_info->fcb_opaque = NULL;
+		rte_mbuf_ext_refcnt_set(current_extbuf_info, 1);
+		if (op_type == OPERATION_COMPRESSION)
+			current_memzone = test_data->compbuf_memzone;
+		else
+			current_memzone = test_data->uncompbuf_memzone;
+
 		for (i = 0; i < num_bufs; i++) {
-			if (out_of_space == 1 && oos_zlib_decompress)
-				data_size = OUT_OF_SPACE_BUF;
-			else
-				(data_size = strlen(test_bufs[i]) *
-					COMPRESS_BUF_SIZE_RATIO);
-
-			if (prepare_sgl_bufs(NULL, comp_bufs[i],
-			      data_size,
-			      big_data ? buf_pool : ts_params->small_mbuf_pool,
-			      big_data ? buf_pool : ts_params->large_mbuf_pool,
-			      big_data ? 0 : MAX_SEGS,
-			      big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE)
-					< 0)
-				goto exit;
+			rte_pktmbuf_attach_extbuf(current_bufs[i],
+					current_memzone->addr,
+					current_memzone->iova,
+					current_memzone->len,
+					current_extbuf_info);
+			rte_pktmbuf_append(current_bufs[i],
+					current_memzone->len);
 		}
-
 	} else {
 		for (i = 0; i < num_bufs; i++) {
-			if (out_of_space == 1 && oos_zlib_decompress)
-				data_size = OUT_OF_SPACE_BUF;
-			else {
-				float ratio =
-				((test_data->zlib_dir == ZLIB_DECOMPRESS ||
-				   test_data->zlib_dir == ZLIB_NONE) &&
-				  overflow_tst == OVERFLOW_ENABLED) ?
-					 COMPRESS_BUF_SIZE_RATIO_OVERFLOW :
-					 COMPRESS_BUF_SIZE_RATIO;
-
-				data_size = strlen(test_bufs[i]) * ratio;
-			}
-			buf_ptr = rte_pktmbuf_append(comp_bufs[i], data_size);
-			if (buf_ptr == NULL) {
-				RTE_LOG(ERR, USER1,
-					"Append extra bytes to the destination mbuf failed\n");
-				goto exit;
+
+			/* data size calculation */
+			data_size = test_mbufs_calculate_data_size(
+					op_type,
+					out_of_space_and_zlib,
+					test_priv_data,
+					int_data,
+					test_data,
+					i);
+
+			/* data allocation */
+			if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
+				ret = prepare_sgl_bufs(NULL, current_bufs[i],
+				      data_size,
+				      big_data ? buf_pool :
+						ts_params->small_mbuf_pool,
+				      big_data ? buf_pool :
+						ts_params->large_mbuf_pool,
+				      big_data ? 0 : MAX_SEGS,
+				      big_data ? MAX_DATA_MBUF_SIZE :
+						 SMALL_SEG_SIZE);
+				if (ret < 0)
+					return -1;
+			} else {
+				buf_ptr = rte_pktmbuf_append(current_bufs[i],
+						data_size);
+				if (buf_ptr == NULL) {
+					RTE_LOG(ERR, USER1,
+						"Append extra bytes to the destination mbuf failed\n");
+					return -1;
+				}
 			}
 		}
 	}
 
+	return 0;
+}
+
+/**
+ * The main compression function.
+ *
+ * Function performs compression operation.
+ * Operation(s) configuration, depending on CLI parameters.
+ * Operation(s) processing.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param test_priv_data
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_comp_run(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *test_priv_data)
+{
+	/* local variables: */
+	struct priv_op_data *priv_data;
+	unsigned int i;
+	uint16_t num_priv_xforms = 0;
+	int ret;
+	int ret_status = 0;
+	char *buf_ptr;
+
+	struct comp_testsuite_params *ts_params = &testsuite_params;
+
+	/* from test_data: */
+	enum rte_comp_op_type operation_type = test_data->compress_state;
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+
+	/* from int_data: */
+	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
+	unsigned int num_xforms = int_data->num_xforms;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from test_priv_data: */
+	struct rte_mbuf **comp_bufs = test_priv_data->comp_bufs;
+	struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
+	struct rte_comp_op **ops = test_priv_data->ops;
+	struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
+	void **priv_xforms = test_priv_data->priv_xforms;
+
+	const struct rte_compressdev_capabilities *capa =
+		rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
+
 	/* Build the compression operations */
 	ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Compress operations could not be allocated "
 			"from the mempool\n");
+		ret_status = -1;
 		goto exit;
 	}
 
-
 	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;
-		if (compress_state == RTE_COMP_OP_STATELESS)
+
+		if (operation_type == RTE_COMP_OP_STATELESS) {
 			ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
-		else {
+		} else {
 			RTE_LOG(ERR, USER1,
-				"Stateful operations are not supported "
-				"in these tests yet\n");
+				"Compression: stateful operations are not "
+				"supported in these tests yet\n");
+			ret_status = -1;
 			goto exit;
 		}
 		ops[i]->input_chksum = 0;
@@ -1007,14 +1213,16 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	}
 
 	/* Compress data (either with Zlib API or compressdev API */
-	if (zlib_dir == ZLIB_COMPRESS || zlib_dir == ZLIB_ALL) {
+	if (zlib_compress) {
 		for (i = 0; i < num_bufs; i++) {
 			const struct rte_comp_xform *compress_xform =
 				compress_xforms[i % num_xforms];
 			ret = compress_zlib(ops[i], compress_xform,
 					DEFAULT_MEM_LEVEL);
-			if (ret < 0)
+			if (ret < 0) {
+				ret_status = -1;
 				goto exit;
+			}
 
 			ops_processed[i] = ops[i];
 		}
@@ -1022,24 +1230,26 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		/* Create compress private xform data */
 		for (i = 0; i < num_xforms; i++) {
 			ret = rte_compressdev_private_xform_create(0,
-				(const struct rte_comp_xform *)compress_xforms[i],
+				(const struct rte_comp_xform *)
+					compress_xforms[i],
 				&priv_xforms[i]);
 			if (ret < 0) {
 				RTE_LOG(ERR, USER1,
 					"Compression private xform "
 					"could not be created\n");
+				ret_status = -1;
 				goto exit;
 			}
 			num_priv_xforms++;
 		}
-
 		if (capa->comp_feature_flags &
 				RTE_COMP_FF_SHAREABLE_PRIV_XFORM) {
 			/* Attach shareable private xform data to ops */
 			for (i = 0; i < num_bufs; i++)
-				ops[i]->private_xform = priv_xforms[i % num_xforms];
+				ops[i]->private_xform =
+						priv_xforms[i % num_xforms];
 		} else {
-			/* Create rest of the private xforms for the other ops */
+		/* Create rest of the private xforms for the other ops */
 			for (i = num_xforms; i < num_bufs; i++) {
 				ret = rte_compressdev_private_xform_create(0,
 					compress_xforms[i % num_xforms],
@@ -1048,26 +1258,28 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 					RTE_LOG(ERR, USER1,
 						"Compression private xform "
 						"could not be created\n");
+					ret_status = -1;
 					goto exit;
 				}
 				num_priv_xforms++;
 			}
-
 			/* Attach non shareable private xform data to ops */
 			for (i = 0; i < num_bufs; i++)
 				ops[i]->private_xform = priv_xforms[i];
 		}
 
 recovery_lb:
-		ret = test_run_enqueue_dequeue(ops, num_bufs, ops_processed);
+		ret = test_run_enqueue_dequeue(ops, ops_processed, num_bufs);
 		if (ret < 0) {
 			RTE_LOG(ERR, USER1,
-				"Enqueue/dequeue operation failed\n");
+				"Compression: enqueue/dequeue operation failed\n");
+			ret_status = -1;
 			goto exit;
 		}
 
 		for (i = 0; i < num_bufs; i++) {
-			compressed_data_size[i] += ops_processed[i]->produced;
+			test_priv_data->compressed_data_size[i] +=
+					ops_processed[i]->produced;
 
 			if (ops_processed[i]->status ==
 				RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE) {
@@ -1088,21 +1300,83 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 				if (buf_ptr == NULL) {
 					RTE_LOG(ERR, USER1,
 						"Data recovery: append extra bytes to the current mbuf failed\n");
+					ret_status = -1;
 					goto exit;
 				}
 				goto recovery_lb;
 			}
 		}
-		deqd_retries = 0;
+	}
+
+exit:
+	/* Free resources */
+	if (ret_status < 0)
+		for (i = 0; i < num_bufs; i++) {
+			rte_comp_op_free(ops[i]);
+			ops_processed[i] = NULL;
+		}
 
-		/* Free compress private xforms */
-		for (i = 0; i < num_priv_xforms; i++) {
+	/* Free compress private xforms */
+	for (i = 0; i < num_priv_xforms; i++) {
+		if (priv_xforms[i] != NULL) {
 			rte_compressdev_private_xform_free(0, priv_xforms[i]);
 			priv_xforms[i] = NULL;
 		}
-		num_priv_xforms = 0;
 	}
 
+	return ret_status;
+}
+
+/**
+ * Prints out the test report. Memory freeing.
+ *
+ * Called after successful compression.
+ * Operation(s) status validation and decompression buffers freeing.
+
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param test_priv_data
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 2: Some operation is not supported
+ *   - 1: Decompression should be skipped
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_comp_finalize(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *test_priv_data)
+{
+	/* local variables: */
+	unsigned int i;
+	struct priv_op_data *priv_data;
+
+	/* from int_data: */
+	unsigned int num_xforms = int_data->num_xforms;
+	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
+	uint16_t *buf_idx = int_data->buf_idx;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from test_priv_data: */
+	struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
+	uint64_t *compress_checksum = test_priv_data->compress_checksum;
+	struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
+	struct rte_comp_op **ops = test_priv_data->ops;
+
+	/* from test_data: */
+	unsigned int out_of_space = test_data->out_of_space;
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
+
 	for (i = 0; i < num_bufs; i++) {
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		uint16_t xform_idx = priv_data->orig_idx % num_xforms;
@@ -1111,7 +1385,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		enum rte_comp_huffman huffman_type =
 			compress_xform->deflate.huffman;
 		char engine[] = "zlib (directly, not PMD)";
-		if (zlib_dir != ZLIB_COMPRESS && zlib_dir != ZLIB_ALL)
+		if (zlib_decompress)
 			strlcpy(engine, "PMD", sizeof(engine));
 
 		RTE_LOG(DEBUG, USER1, "Buffer %u compressed by %s from %u to"
@@ -1134,116 +1408,103 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	 * compress operation information is needed for the decompression stage)
 	 */
 	for (i = 0; i < num_bufs; i++) {
-		if (out_of_space && oos_zlib_decompress) {
+		if (out_of_space && !zlib_compress) {
 			if (ops_processed[i]->status !=
 				RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
-				ret_status = TEST_FAILED;
 				RTE_LOG(ERR, USER1,
 					"Operation without expected out of "
 					"space status error\n");
-				goto exit;
+				return -1;
 			} else
 				continue;
 		}
 
 		if (ops_processed[i]->status != RTE_COMP_OP_STATUS_SUCCESS) {
-			if (overflow_tst == OVERFLOW_ENABLED) {
+			if (test_data->overflow == OVERFLOW_ENABLED) {
 				if (ops_processed[i]->status ==
 				RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
-					ret_status = 1;
 					RTE_LOG(INFO, USER1,
 					"Out-of-space-recoverable functionality"
 					" is not supported on this device\n");
-					goto exit;
+					return 2;
 				}
 			}
+
 			RTE_LOG(ERR, USER1,
 				"Some operations were not successful\n");
-			goto exit;
+			return -1;
 		}
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		rte_pktmbuf_free(uncomp_bufs[priv_data->orig_idx]);
 		uncomp_bufs[priv_data->orig_idx] = NULL;
 	}
 
-	if (out_of_space && oos_zlib_decompress) {
-		ret_status = TEST_SUCCESS;
-		goto exit;
-	}
+	if (out_of_space && !zlib_compress)
+		return 1;
 
-	/* Allocate buffers for decompressed data */
-	ret = rte_pktmbuf_alloc_bulk(buf_pool, uncomp_bufs, num_bufs);
-	if (ret < 0) {
-		RTE_LOG(ERR, USER1,
-			"Destination mbufs could not be allocated "
-			"from the mempool\n");
-		goto exit;
-	}
+	return 0;
+}
 
-	if (test_data->use_external_mbufs) {
-		decompbuf_info.free_cb = extbuf_free_callback;
-		decompbuf_info.fcb_opaque = NULL;
-		rte_mbuf_ext_refcnt_set(&decompbuf_info, 1);
-		for (i = 0; i < num_bufs; i++) {
-			rte_pktmbuf_attach_extbuf(uncomp_bufs[i],
-					test_data->uncompbuf_memzone->addr,
-					test_data->uncompbuf_memzone->iova,
-					test_data->uncompbuf_memzone->len,
-					&decompbuf_info);
-			rte_pktmbuf_append(uncomp_bufs[i],
-					test_data->uncompbuf_memzone->len);
-		}
-	} else if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
-		for (i = 0; i < num_bufs; i++) {
-			priv_data = (struct priv_op_data *)
-					(ops_processed[i] + 1);
-			if (out_of_space == 1 && oos_zlib_compress)
-				data_size = OUT_OF_SPACE_BUF;
-			else if (test_data->decompress_output_block_size != 0)
-				data_size =
-					test_data->decompress_output_block_size;
-			else
-				data_size =
-				strlen(test_bufs[priv_data->orig_idx]) + 1;
-
-			if (prepare_sgl_bufs(NULL, uncomp_bufs[i],
-			       data_size,
-			       big_data ? buf_pool : ts_params->small_mbuf_pool,
-			       big_data ? buf_pool : ts_params->large_mbuf_pool,
-			       big_data ? 0 : MAX_SEGS,
-			       big_data ? MAX_DATA_MBUF_SIZE : SMALL_SEG_SIZE)
-					< 0)
-				goto exit;
-		}
+/**
+ * The main decompression function.
+ *
+ * Function performs decompression operation.
+ * Operation(s) configuration, depending on CLI parameters.
+ * Operation(s) processing.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param test_priv_data
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_decomp_run(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		struct test_private_arrays *test_priv_data)
+{
 
-	} else {
-		for (i = 0; i < num_bufs; i++) {
-			priv_data = (struct priv_op_data *)
-					(ops_processed[i] + 1);
-			if (out_of_space == 1 && oos_zlib_compress)
-				data_size = OUT_OF_SPACE_BUF;
-			else if (test_data->decompress_output_block_size != 0)
-				data_size =
-					test_data->decompress_output_block_size;
-			else
-				data_size =
-				strlen(test_bufs[priv_data->orig_idx]) + 1;
+	/* local variables: */
+	struct priv_op_data *priv_data;
+	unsigned int i;
+	uint16_t num_priv_xforms = 0;
+	int ret;
+	int ret_status = 0;
 
-			buf_ptr = rte_pktmbuf_append(uncomp_bufs[i], data_size);
-			if (buf_ptr == NULL) {
-				RTE_LOG(ERR, USER1,
-					"Append extra bytes to the decompressed mbuf failed\n");
-				goto exit;
-			}
-		}
-	}
+	struct comp_testsuite_params *ts_params = &testsuite_params;
+
+	/* from test_data: */
+	enum rte_comp_op_type operation_type = test_data->decompress_state;
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
+
+	/* from int_data: */
+	struct rte_comp_xform **decompress_xforms = int_data->decompress_xforms;
+	unsigned int num_xforms = int_data->num_xforms;
+	unsigned int num_bufs = int_data->num_bufs;
+
+	/* from test_priv_data: */
+	struct rte_mbuf **uncomp_bufs = test_priv_data->uncomp_bufs;
+	struct rte_comp_op **ops = test_priv_data->ops;
+	struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
+	void **priv_xforms = test_priv_data->priv_xforms;
+	uint32_t *compressed_data_size = test_priv_data->compressed_data_size;
+	void **stream = test_priv_data->stream;
+
+	const struct rte_compressdev_capabilities *capa =
+		rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
 
-	/* Build the decompression operations */
 	ret = rte_comp_op_bulk_alloc(ts_params->op_pool, ops, num_bufs);
 	if (ret < 0) {
 		RTE_LOG(ERR, USER1,
 			"Decompress operations could not be allocated "
 			"from the mempool\n");
+		ret_status = -1;
 		goto exit;
 	}
 
@@ -1256,22 +1517,25 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		 * Set the length of the compressed data to the
 		 * number of bytes that were produced in the previous stage
 		 */
+
 		if (compressed_data_size[i])
 			ops[i]->src.length = compressed_data_size[i];
 		else
 			ops[i]->src.length = ops_processed[i]->produced;
 
 		ops[i]->dst.offset = 0;
-		if (decompress_state == RTE_COMP_OP_STATELESS) {
+
+		if (operation_type == RTE_COMP_OP_STATELESS) {
 			ops[i]->flush_flag = RTE_COMP_FLUSH_FINAL;
 			ops[i]->op_type = RTE_COMP_OP_STATELESS;
-		} else if (zlib_dir == ZLIB_COMPRESS || zlib_dir == ZLIB_NONE) {
+		} else if (!zlib_decompress) {
 			ops[i]->flush_flag = RTE_COMP_FLUSH_SYNC;
 			ops[i]->op_type = RTE_COMP_OP_STATEFUL;
 		} else {
 			RTE_LOG(ERR, USER1,
-				"Stateful operations are not supported "
-				"in these tests yet\n");
+				"Decompression: stateful operations are"
+				" not supported in these tests yet\n");
+			ret_status = -1;
 			goto exit;
 		}
 		ops[i]->input_chksum = 0;
@@ -1290,7 +1554,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	rte_comp_op_bulk_free(ops_processed, num_bufs);
 
 	/* Decompress data (either with Zlib API or compressdev API */
-	if (zlib_dir == ZLIB_DECOMPRESS || zlib_dir == ZLIB_ALL) {
+	if (zlib_decompress) {
 		for (i = 0; i < num_bufs; i++) {
 			priv_data = (struct priv_op_data *)(ops[i] + 1);
 			uint16_t xform_idx = priv_data->orig_idx % num_xforms;
@@ -1298,13 +1562,15 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 				decompress_xforms[xform_idx];
 
 			ret = decompress_zlib(ops[i], decompress_xform);
-			if (ret < 0)
+			if (ret < 0) {
+				ret_status = -1;
 				goto exit;
+			}
 
 			ops_processed[i] = ops[i];
 		}
 	} else {
-		if (decompress_state == RTE_COMP_OP_STATELESS) {
+		if (operation_type == RTE_COMP_OP_STATELESS) {
 			/* Create decompress private xform data */
 			for (i = 0; i < num_xforms; i++) {
 				ret = rte_compressdev_private_xform_create(0,
@@ -1315,6 +1581,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 					RTE_LOG(ERR, USER1,
 						"Decompression private xform "
 						"could not be created\n");
+					ret_status = -1;
 					goto exit;
 				}
 				num_priv_xforms++;
@@ -1341,7 +1608,9 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 					      &priv_xforms[i]);
 					if (ret < 0) {
 						RTE_LOG(ERR, USER1,
-							"Decompression private xform could not be created\n");
+							"Decompression private xform"
+							" could not be created\n");
+						ret_status = -1;
 						goto exit;
 					}
 					num_priv_xforms++;
@@ -1361,59 +1630,86 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		} else {
 			/* Create a stream object for stateful decompression */
 			ret = rte_compressdev_stream_create(0,
-					decompress_xforms[0], &stream);
+					decompress_xforms[0], stream);
 			if (ret < 0) {
 				RTE_LOG(ERR, USER1,
 					"Decompression stream could not be created, error %d\n",
 					ret);
+				ret_status = -1;
 				goto exit;
 			}
 			/* Attach stream to ops */
 			for (i = 0; i < num_bufs; i++)
-				ops[i]->stream = stream;
+				ops[i]->stream = *stream;
 		}
 
-next_step:
-		/* Enqueue and dequeue all operations */
-		num_enqd = rte_compressdev_enqueue_burst(0, 0, ops, num_bufs);
-		if (num_enqd < num_bufs) {
-			RTE_LOG(ERR, USER1,
-				"The operations could not be enqueued\n");
-			goto exit;
-		}
+		test_priv_data->num_priv_xforms = num_priv_xforms;
+	}
 
-		num_total_deqd = 0;
-		do {
-			/*
-			 * If retrying a dequeue call, wait for 10 ms to allow
-			 * enough time to the driver to process the operations
-			 */
-			if (deqd_retries != 0) {
-				/*
-				 * Avoid infinite loop if not all the
-				 * operations get out of the device
-				 */
-				if (deqd_retries == MAX_DEQD_RETRIES) {
-					RTE_LOG(ERR, USER1,
-						"Not all operations could be "
-						"dequeued\n");
-					goto exit;
-				}
-				usleep(DEQUEUE_WAIT_TIME);
-			}
-			num_deqd = rte_compressdev_dequeue_burst(0, 0,
-					&ops_processed[num_total_deqd], num_bufs);
-			num_total_deqd += num_deqd;
-			deqd_retries++;
-		} while (num_total_deqd < num_enqd);
+exit:
+	return ret_status;
+}
 
-		deqd_retries = 0;
-	}
+/**
+ * Prints out the test report. Memory freeing.
+ *
+ * Called after successful decompression.
+ * Operation(s) status validation and compression buffers freeing.
+
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param test_priv_data
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 2: Next step must be executed by the caller (stateful decompression only)
+ *   - 1: On success (caller should stop and exit)
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_deflate_decomp_finalize(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *test_priv_data)
+{
+	/* local variables: */
+	unsigned int i;
+	struct priv_op_data *priv_data;
+	static unsigned int step;
+
+	/* from int_data: */
+	uint16_t *buf_idx = int_data->buf_idx;
+	unsigned int num_bufs = int_data->num_bufs;
+	const char * const *test_bufs = int_data->test_bufs;
+	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
+
+	/* from test_priv_data: */
+	struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
+	struct rte_mbuf **comp_bufs = test_priv_data->comp_bufs;
+	struct rte_comp_op **ops = test_priv_data->ops;
+	uint64_t *compress_checksum = test_priv_data->compress_checksum;
+	unsigned int *decomp_produced_data_size =
+			test_priv_data->decomp_produced_data_size;
+	char **all_decomp_data = test_priv_data->all_decomp_data;
+
+	/* from test_data: */
+	unsigned int out_of_space = test_data->out_of_space;
+	enum rte_comp_op_type operation_type = test_data->decompress_state;
+
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
 
 	for (i = 0; i < num_bufs; i++) {
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		char engine[] = "zlib, (directly, no PMD)";
-		if (zlib_dir != ZLIB_DECOMPRESS && zlib_dir != ZLIB_ALL)
+		if (zlib_compress)
 			strlcpy(engine, "pmd", sizeof(engine));
 		RTE_LOG(DEBUG, USER1,
 			"Buffer %u decompressed by %s from %u to %u bytes\n",
@@ -1427,19 +1723,19 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	 * compress operation information is still needed)
 	 */
 	for (i = 0; i < num_bufs; i++) {
-		if (out_of_space && oos_zlib_compress) {
+		if (out_of_space && !zlib_decompress) {
 			if (ops_processed[i]->status !=
-					RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
-				ret_status = TEST_FAILED;
+				RTE_COMP_OP_STATUS_OUT_OF_SPACE_TERMINATED) {
+
 				RTE_LOG(ERR, USER1,
 					"Operation without expected out of "
 					"space status error\n");
-				goto exit;
+				return -1;
 			} else
 				continue;
 		}
 
-		if (decompress_state == RTE_COMP_OP_STATEFUL
+		if (operation_type == RTE_COMP_OP_STATEFUL
 			&& (ops_processed[i]->status ==
 				RTE_COMP_OP_STATUS_OUT_OF_SPACE_RECOVERABLE
 			    || ops_processed[i]->status ==
@@ -1449,28 +1745,29 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 					ops_processed[i]->m_dst,
 					ops_processed[i]->dst.offset,
 					ops_processed[i]->produced,
-					all_decomp_data +
-						decomp_produced_data_size);
-			if (ptr != all_decomp_data + decomp_produced_data_size)
-				rte_memcpy(all_decomp_data +
-					   decomp_produced_data_size,
+					*all_decomp_data +
+						*decomp_produced_data_size);
+			if (ptr != *all_decomp_data +
+					*decomp_produced_data_size)
+				rte_memcpy(*all_decomp_data +
+					   *decomp_produced_data_size,
 					   ptr, ops_processed[i]->produced);
-			decomp_produced_data_size += ops_processed[i]->produced;
+
+			*decomp_produced_data_size +=
+					ops_processed[i]->produced;
 			if (ops_processed[i]->src.length >
 					ops_processed[i]->consumed) {
 				if (ops_processed[i]->status ==
 						RTE_COMP_OP_STATUS_SUCCESS) {
-					ret_status = -1;
 					RTE_LOG(ERR, USER1,
 					      "Operation finished too early\n");
-					goto exit;
+					return -1;
 				}
 				step++;
 				if (step >= test_data->decompress_steps_max) {
-					ret_status = -1;
 					RTE_LOG(ERR, USER1,
 					  "Operation exceeded maximum steps\n");
-					goto exit;
+					return -1;
 				}
 				ops[i] = ops_processed[i];
 				ops[i]->status =
@@ -1479,7 +1776,9 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 						ops_processed[i]->consumed;
 				ops[i]->src.length -=
 						ops_processed[i]->consumed;
-				goto next_step;
+				/* repeat the operation */
+				//goto next_step;
+				return 2;
 			} else {
 				/* Compare the original stream with the */
 				/* decompressed stream (in size and the data) */
@@ -1487,22 +1786,22 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 						(ops_processed[i] + 1);
 				const char *buf1 =
 						test_bufs[priv_data->orig_idx];
-				const char *buf2 = all_decomp_data;
+				const char *buf2 = *all_decomp_data;
 
 				if (compare_buffers(buf1, strlen(buf1) + 1,
-					  buf2, decomp_produced_data_size) < 0)
-					goto exit;
+					  buf2, *decomp_produced_data_size) < 0)
+					return -1;
 				/* 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],
+			"The checksums differ\n"
+			"Compression Checksum: %" PRIu64 "\tDecompression "
+			"Checksum: %" PRIu64 "\n", compress_checksum[i],
 					       ops_processed[i]->output_chksum);
-						goto exit;
+						return -1;
 					}
 				}
 			}
@@ -1510,18 +1809,58 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 			   RTE_COMP_OP_STATUS_SUCCESS) {
 			RTE_LOG(ERR, USER1,
 				"Some operations were not successful\n");
-			goto exit;
+			return -1;
 		}
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
 		rte_pktmbuf_free(comp_bufs[priv_data->orig_idx]);
 		comp_bufs[priv_data->orig_idx] = NULL;
 	}
 
-	if ((out_of_space && oos_zlib_compress)
-			|| (decompress_state == RTE_COMP_OP_STATEFUL)) {
-		ret_status = TEST_SUCCESS;
-		goto exit;
-	}
+	if (out_of_space && !zlib_decompress)
+		return 1;
+
+	return 0;
+}
+
+/**
+ * Validation of the output (compression/decompression) data.
+ *
+ * The function compares the source stream with the output stream,
+ * after decompression, to check if compression/decompression
+ * was correct.
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @param test_priv_data
+ *   A container used for aggregation all the private test arrays.
+ * @return
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+static int
+test_results_validation(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data,
+		const struct test_private_arrays *test_priv_data)
+{
+	/* local variables: */
+	unsigned int i;
+	struct priv_op_data *priv_data;
+	const char *buf1;
+	const char *buf2;
+	char *contig_buf = NULL;
+	uint32_t data_size;
+
+	/* from int_data: */
+	struct rte_comp_xform **compress_xforms = int_data->compress_xforms;
+	unsigned int num_bufs = int_data->num_bufs;
+	const char * const *test_bufs = int_data->test_bufs;
+
+	/* from test_priv_data: */
+	uint64_t *compress_checksum = test_priv_data->compress_checksum;
+	struct rte_comp_op **ops_processed = test_priv_data->ops_processed;
 
 	/*
 	 * Compare the original stream with the decompressed stream
@@ -1529,13 +1868,13 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	 */
 	for (i = 0; i < num_bufs; i++) {
 		priv_data = (struct priv_op_data *)(ops_processed[i] + 1);
-		const char *buf1 = test_data->use_external_mbufs ?
+		buf1 = test_data->use_external_mbufs ?
 				test_data->inbuf_memzone->addr :
 				test_bufs[priv_data->orig_idx];
-		const char *buf2;
 		data_size = test_data->use_external_mbufs ?
 				test_data->inbuf_data_size :
 				strlen(buf1) + 1;
+
 		contig_buf = rte_malloc(NULL, ops_processed[i]->produced, 0);
 		if (contig_buf == NULL) {
 			RTE_LOG(ERR, USER1, "Contiguous buffer could not "
@@ -1565,24 +1904,205 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		rte_free(contig_buf);
 		contig_buf = NULL;
 	}
+	return 0;
+
+exit:
+	rte_free(contig_buf);
+	return -1;
+}
+
+/**
+ * Compresses and decompresses input stream with compressdev API and Zlib API
+ *
+ * Basic test function. Common for all the functional tests.
+ * -1 returned if function fail.
+ *
+ * @param int_data
+ *   Interim data containing session/transformation objects.
+ * @param test_data
+ *   The test parameters set by users (command line parameters).
+ * @return
+ *   - 1: Some operation not supported
+ *   - 0: On success.
+ *   - -1: On error.
+ */
+
+static int
+test_deflate_comp_decomp(const struct interim_data_params *int_data,
+		const struct test_data_params *test_data)
+{
+	unsigned int num_bufs = int_data->num_bufs;
+	unsigned int out_of_space = test_data->out_of_space;
+
+	void *stream = NULL;
+	char *all_decomp_data = NULL;
+	unsigned int decomp_produced_data_size = 0;
+
+	int ret_status = -1;
+	int ret;
+	struct rte_mbuf *uncomp_bufs[num_bufs];
+	struct rte_mbuf *comp_bufs[num_bufs];
+	struct rte_comp_op *ops[num_bufs];
+	struct rte_comp_op *ops_processed[num_bufs];
+	void *priv_xforms[num_bufs];
+	unsigned int i;
+
+	uint64_t compress_checksum[num_bufs];
+	uint32_t compressed_data_size[num_bufs];
+	char *contig_buf = NULL;
+
+	struct rte_mbuf_ext_shared_info compbuf_info;
+	struct rte_mbuf_ext_shared_info decompbuf_info;
+
+	const struct rte_compressdev_capabilities *capa;
+
+	/* Compressing with CompressDev */
+	unsigned int zlib_compress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_COMPRESS);
+	unsigned int zlib_decompress =
+			(test_data->zlib_dir == ZLIB_ALL ||
+			test_data->zlib_dir == ZLIB_DECOMPRESS);
+
+	struct test_private_arrays test_priv_data;
+
+	test_priv_data.uncomp_bufs = uncomp_bufs;
+	test_priv_data.comp_bufs = comp_bufs;
+	test_priv_data.ops = ops;
+	test_priv_data.ops_processed = ops_processed;
+	test_priv_data.priv_xforms = priv_xforms;
+	test_priv_data.compress_checksum = compress_checksum;
+	test_priv_data.compressed_data_size = compressed_data_size;
+
+	test_priv_data.stream = &stream;
+	test_priv_data.all_decomp_data = &all_decomp_data;
+	test_priv_data.decomp_produced_data_size = &decomp_produced_data_size;
+
+	test_priv_data.num_priv_xforms = 0; /* it's used for deompression only */
+
+	capa = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
+	if (capa == NULL) {
+		RTE_LOG(ERR, USER1,
+			"Compress device does not support DEFLATE\n");
+		return -1;
+	}
+	//test_objects_init(&test_priv_data, num_bufs);
 
-	ret_status = TEST_SUCCESS;
+	/* Prepare the source mbufs with the data */
+	ret = test_setup_com_bufs(int_data, test_data, &test_priv_data);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+/* COMPRESSION  */
+
+	/* Prepare output (destination) mbufs for compressed data */
+	ret = test_setup_output_bufs(
+			OPERATION_COMPRESSION,
+			out_of_space == 1 && !zlib_compress,
+			&test_priv_data,
+			int_data,
+			test_data,
+			&compbuf_info);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	/* Run compression */
+	ret = test_deflate_comp_run(int_data, test_data, &test_priv_data);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	ret = test_deflate_comp_finalize(int_data, test_data, &test_priv_data);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	} else if (ret == 1) {
+		ret_status = 0;
+		goto exit;
+	} else if (ret == 2) {
+		ret_status = 1;	 /* some operation not supported */
+		goto exit;
+	}
+
+/* DECOMPRESSION  */
+
+	/* Prepare output (destination) mbufs for decompressed data */
+	ret = test_setup_output_bufs(
+			OPERATION_DECOMPRESSION,
+			out_of_space == 1 && !zlib_decompress,
+			&test_priv_data,
+			int_data,
+			test_data,
+			&decompbuf_info);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	/* Run decompression */
+	ret = test_deflate_decomp_run(int_data, test_data, &test_priv_data);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+
+	if (!zlib_decompress) {
+next_step:	/* next step for stateful decompression only */
+		ret = test_run_enqueue_dequeue(ops, ops_processed, num_bufs);
+		if (ret < 0) {
+			ret_status = -1;
+			RTE_LOG(ERR, USER1,
+				"Decompression: enqueue/dequeue operation failed\n");
+		}
+	}
+
+	ret = test_deflate_decomp_finalize(int_data, test_data, &test_priv_data);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	} else if (ret == 1) {
+		ret_status = 0;
+		goto exit;
+	} else if (ret == 2) {
+		goto next_step;
+	}
+
+/* FINAL PROCESSING  */
+
+	ret = test_results_validation(int_data, test_data, &test_priv_data);
+	if (ret < 0) {
+		ret_status = -1;
+		goto exit;
+	}
+	ret_status = 0;
 
 exit:
 	/* Free resources */
+
+	if (stream != NULL)
+		rte_compressdev_stream_free(0, stream);
+	if (all_decomp_data != NULL)
+		rte_free(all_decomp_data);
+
+	/* Free compress private xforms */
+	for (i = 0; i < test_priv_data.num_priv_xforms; i++) {
+		if (priv_xforms[i] != NULL) {
+			rte_compressdev_private_xform_free(0, priv_xforms[i]);
+			priv_xforms[i] = NULL;
+		}
+	}
+
 	for (i = 0; i < num_bufs; i++) {
 		rte_pktmbuf_free(uncomp_bufs[i]);
 		rte_pktmbuf_free(comp_bufs[i]);
 		rte_comp_op_free(ops[i]);
 		rte_comp_op_free(ops_processed[i]);
 	}
-	for (i = 0; i < num_priv_xforms; i++)
-		if (priv_xforms[i] != NULL)
-			rte_compressdev_private_xform_free(0, priv_xforms[i]);
-	if (stream != NULL)
-		rte_compressdev_stream_free(0, stream);
-	if (all_decomp_data != NULL)
-		rte_free(all_decomp_data);
 	rte_free(contig_buf);
 
 	return ret_status;
@@ -2700,3 +3220,4 @@ test_compressdev(void)
 }
 
 REGISTER_TEST_COMMAND(compressdev_autotest, test_compressdev);
+
diff --git a/doc/guides/rel_notes/release_19_11.rst b/doc/guides/rel_notes/release_19_11.rst
index 6d2f8503f..490c07e84 100644
--- a/doc/guides/rel_notes/release_19_11.rst
+++ b/doc/guides/rel_notes/release_19_11.rst
@@ -246,6 +246,11 @@ New Features
   * Added a console command to testpmd app, ``show port (port_id) ptypes`` which
     gives ability to print port supported ptypes in different protocol layers.
 
+* **Refactored compression unit tests.**
+
+  Refactored core function to get clear code structure, better for maintenance.
+  Created smaller specialized functions.
+
 
 Removed Items
 -------------
-- 
2.17.1

Re: [dpdk-dev] [EXT] [PATCH v4 1/1] test/compress: unit tests refactoring

[Shally Verma]

> -----Original Message-----
> From: Artur Trybula <arturx.trybula@intel.com>
> Sent: Thursday, November 7, 2019 10:56 PM
> To: dev@dpdk.org; fiona.trahe@intel.com; Shally Verma
> <shallyv@marvell.com>; adamx.dybkowski@intel.com;
> arturx.trybula@intel.com; akhil.goyal@nxp.com
> Subject: [EXT] [PATCH v4 1/1] test/compress: unit tests refactoring
> 
> External Email
> 
> ----------------------------------------------------------------------
> Core engine refactoring (test_deflate_comp_decomp function).
> Smaller specialized functions created.
> 
> Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
> Acked-by: Adam Dybkowski <adamx.dybkowski@intel.com>
> ---
Acked-by : Shally Verma <shallyv@marvell.com>
..

> --
> 2.17.1

Re: [dpdk-dev] [EXT] [PATCH v4 1/1] test/compress: unit tests refactoring

[Akhil Goyal]

> > ----------------------------------------------------------------------
> > Core engine refactoring (test_deflate_comp_decomp function).
> > Smaller specialized functions created.
> >
> > Signed-off-by: Artur Trybula <arturx.trybula@intel.com>
> > Acked-by: Adam Dybkowski <adamx.dybkowski@intel.com>
> > ---
> Acked-by : Shally Verma <shallyv@marvell.com>
> ..
Applied to dpdk-next-crypto

Thanks.

Re: [dpdk-dev] [PATCH v4 1/1] test/compress: unit tests refactoring

[Thomas Monjalon]

07/11/2019 18:26, Artur Trybula:
> --- a/doc/guides/rel_notes/release_19_11.rst
> +++ b/doc/guides/rel_notes/release_19_11.rst
> @@ -246,6 +246,11 @@ New Features
> +* **Refactored compression unit tests.**
> +
> +  Refactored core function to get clear code structure, better for maintenance.
> +  Created smaller specialized functions.

This is not a new feature.
I remove it from release notes while pulling Akhil's tree.