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

["Trybula, ArturX" <arturx.trybula@intel.com>]

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