[Accel-config] [PATCH v1 13/14] accel-config/test: Add test code of operation Decompress

Add test code of operation Decompress

Signed-off-by: Li Zhang <li4.zhang(a)intel.com>
---
 test/algorithms/iaa_compress.h |   3 +
 test/iaa.c                     | 182 +++++++++++++++++++++++++++++++++
 test/iaa.h                     |   3 +
 test/iaa_prep.c                |  14 +++
 test/iaa_test.c                |  11 ++
 5 files changed, 213 insertions(+)

diff --git a/test/algorithms/iaa_compress.h b/test/algorithms/iaa_compress.h
index 8023ef9..e3cdb6d 100644
--- a/test/algorithms/iaa_compress.h
+++ b/test/algorithms/iaa_compress.h
@@ -9,6 +9,9 @@
 #define IAA_COMPRESS_AECS_SIZE (1568)
 #define IAA_COMPRESS_SRC2_SIZE (IAA_COMPRESS_AECS_SIZE * 2)
 #define IAA_COMPRESS_MAX_DEST_SIZE (2097152 * 2)
+#define IAA_DECOMPRESS_AECS_SIZE (5376)
+#define IAA_DECOMPRESS_SRC2_SIZE (IAA_DECOMPRESS_AECS_SIZE * 2)
+#define IAA_DECOMPRESS_MAX_DEST_SIZE (2097152 * 2)
 
 static const uint32_t iaa_compress_aecs[IAA_COMPRESS_AECS_SIZE / 4] = {
 0x12345678, // crc
diff --git a/test/iaa.c b/test/iaa.c
index 0c607ee..7cc11c7 100644
--- a/test/iaa.c
+++ b/test/iaa.c
@@ -184,6 +184,37 @@ static int init_compress(struct task *tsk, int tflags, int opcode, unsigned long
 	return ACCTEST_STATUS_OK;
 }
 
+static int init_decompress(struct task *tsk, int tflags, int opcode, unsigned long src1_xfer_size)
+{
+	tsk->pattern = 0x98765432abcdef01;
+	tsk->test_flags = tflags;
+	tsk->xfer_size = src1_xfer_size;
+	tsk->input_size = src1_xfer_size;
+
+	tsk->input = aligned_alloc(32, src1_xfer_size);
+	if (!tsk->input)
+		return -ENOMEM;
+	memset_pattern(tsk->input, tsk->pattern, src1_xfer_size);
+
+	tsk->src1 = aligned_alloc(32, IAA_DECOMPRESS_MAX_DEST_SIZE);
+	if (!tsk->src1)
+		return -ENOMEM;
+	memset_pattern(tsk->src1, 0, IAA_DECOMPRESS_MAX_DEST_SIZE);
+	memcpy(tsk->src1, tsk->input, src1_xfer_size);
+
+	tsk->src2 = aligned_alloc(32, IAA_DECOMPRESS_SRC2_SIZE);
+	if (!tsk->src2)
+		return -ENOMEM;
+	memset_pattern(tsk->src2, 0, IAA_DECOMPRESS_SRC2_SIZE);
+
+	tsk->dst1 = aligned_alloc(32, IAA_DECOMPRESS_MAX_DEST_SIZE);
+	if (!tsk->dst1)
+		return -ENOMEM;
+	memset_pattern(tsk->dst1, 0, IAA_DECOMPRESS_MAX_DEST_SIZE);
+
+	return ACCTEST_STATUS_OK;
+}
+
 int init_task(struct task *tsk, int tflags, int opcode, unsigned long src1_xfer_size)
 {
 	int rc = 0;
@@ -210,6 +241,9 @@ int init_task(struct task *tsk, int tflags, int opcode, unsigned long src1_xfer_
 	case IAX_OPCODE_COMPRESS:
 		rc = init_compress(tsk, tflags, opcode, src1_xfer_size);
 		break;
+	case IAX_OPCODE_DECOMPRESS:
+		rc = init_decompress(tsk, tflags, opcode, src1_xfer_size);
+		break;
 	}
 
 	if (rc != ACCTEST_STATUS_OK) {
@@ -558,6 +592,115 @@ int iaa_compress_multi_task_nodes(struct acctest_context *ctx)
 	return ret;
 }
 
+static int iaa_wait_decompress(struct acctest_context *ctx, struct task *tsk)
+{
+	struct completion_record *comp = tsk->comp;
+	int rc;
+
+	rc = acctest_wait_on_desc_timeout(comp, ctx, ms_timeout);
+	if (rc < 0) {
+		err("decompress desc timeout\n");
+		return ACCTEST_STATUS_TIMEOUT;
+	}
+
+	return ACCTEST_STATUS_OK;
+}
+
+int iaa_decompress_multi_task_nodes(struct acctest_context *ctx)
+{
+	struct task_node *tsk_node = ctx->multi_task_node;
+	int ret = ACCTEST_STATUS_OK;
+
+	// Compress
+	while (tsk_node) {
+		tsk_node->tsk->opcode = IAX_OPCODE_COMPRESS;
+		tsk_node->tsk->dflags |= (IDXD_OP_FLAG_CRAV | IDXD_OP_FLAG_RCR);
+		if ((tsk_node->tsk->test_flags & TEST_FLAGS_BOF) && ctx->bof)
+			tsk_node->tsk->dflags |= IDXD_OP_FLAG_BOF;
+
+		tsk_node->tsk->dflags |= (IDXD_OP_FLAG_WR_SRC2_CMPL | IDXD_OP_FLAG_RD_SRC2_AECS);
+		tsk_node->tsk->iaa_src2_xfer_size = IAA_COMPRESS_AECS_SIZE;
+
+		memcpy(tsk_node->tsk->src2, (void *)iaa_compress_aecs, IAA_COMPRESS_AECS_SIZE);
+
+		tsk_node->tsk->iaa_compr_flags = (IDXD_COMPRESS_FLAG_EOB_BFINAL |
+						  IDXD_COMPRESS_FLAG_FLUSH_OUTPUT);
+		tsk_node->tsk->iaa_max_dst_size = IAA_DECOMPRESS_MAX_DEST_SIZE;
+
+		iaa_prep_compress(tsk_node->tsk);
+		tsk_node = tsk_node->next;
+	}
+
+	info("Submitted all compress jobs\n");
+	tsk_node = ctx->multi_task_node;
+	while (tsk_node) {
+		acctest_desc_submit(ctx, tsk_node->tsk->desc);
+		tsk_node = tsk_node->next;
+	}
+
+	tsk_node = ctx->multi_task_node;
+	while (tsk_node) {
+		ret = iaa_wait_compress(ctx, tsk_node->tsk);
+		if (ret != ACCTEST_STATUS_OK)
+			info("Desc: %p failed with ret: %d\n",
+			     tsk_node->tsk->desc, tsk_node->tsk->comp->status);
+		tsk_node = tsk_node->next;
+	}
+
+	if (ret) {
+		printf("Before decompress, compress failed\n");
+		return ret;
+	}
+
+	// Decompress
+	tsk_node = ctx->multi_task_node;
+	while (tsk_node) {
+		memset_pattern(tsk_node->tsk->src1, 0, tsk_node->tsk->xfer_size);
+		memcpy(tsk_node->tsk->src1, tsk_node->tsk->dst1,
+		       tsk_node->tsk->comp->iax_output_size);
+
+		tsk_node->tsk->opcode = IAX_OPCODE_DECOMPRESS;
+		tsk_node->tsk->xfer_size = tsk_node->tsk->comp->iax_output_size;
+
+		tsk_node->tsk->dflags |= (IDXD_OP_FLAG_CRAV | IDXD_OP_FLAG_RCR);
+		if ((tsk_node->tsk->test_flags & TEST_FLAGS_BOF) && ctx->bof)
+			tsk_node->tsk->dflags |= IDXD_OP_FLAG_BOF;
+
+		tsk_node->tsk->dflags &= ~(IDXD_OP_FLAG_WR_SRC2_CMPL |
+					   IDXD_OP_FLAG_RD_SRC2_AECS);
+		tsk_node->tsk->iaa_src2_xfer_size = 0;
+		tsk_node->tsk->src2 = 0;
+
+		tsk_node->tsk->iaa_decompr_flags = (IDXD_DECOMPRESS_FLAG_SELECT_EOB_BFINAL |
+						    IDXD_DECOMPRESS_FLAG_CHECK_EOB |
+						    IDXD_DECOMPRESS_FLAG_STOP_ON_EOB |
+						    IDXD_DECOMPRESS_FLAG_FLUSH_OUTPUT |
+						    IDXD_DECOMPRESS_FLAG_EN_DECOMPRESS);
+		tsk_node->tsk->iaa_max_dst_size = IAA_DECOMPRESS_MAX_DEST_SIZE;
+
+		iaa_prep_decompress(tsk_node->tsk);
+		tsk_node = tsk_node->next;
+	}
+
+	info("Submitted all decompress jobs\n");
+	tsk_node = ctx->multi_task_node;
+	while (tsk_node) {
+		acctest_desc_submit(ctx, tsk_node->tsk->desc);
+		tsk_node = tsk_node->next;
+	}
+
+	tsk_node = ctx->multi_task_node;
+	while (tsk_node) {
+		ret = iaa_wait_decompress(ctx, tsk_node->tsk);
+		if (ret != ACCTEST_STATUS_OK)
+			info("Desc: %p failed with ret: %d\n",
+			     tsk_node->tsk->desc, tsk_node->tsk->comp->status);
+		tsk_node = tsk_node->next;
+	}
+
+	return ret;
+}
+
 /* mismatch_expected: expect mismatched buffer with success status 0x1 */
 int iaa_task_result_verify(struct task *tsk, int mismatch_expected)
 {
@@ -858,3 +1001,42 @@ int task_result_verify_compress(struct task *tsk, int mismatch_expected)
 
 	return -ENXIO;
 }
+
+int task_result_verify_decompress(struct task *tsk, int mismatch_expected)
+{
+	int i = 0;
+	int rc;
+
+	if (mismatch_expected)
+		warn("invalid arg mismatch_expected for %d\n", tsk->opcode);
+
+	rc = memcmp(tsk->input, tsk->dst1, tsk->input_size);
+
+	if (!mismatch_expected) {
+		if (tsk->input_size - tsk->comp->iax_output_size) {
+			err("Decompress mismatch, exp len %d, act len %d\n",
+			    tsk->input_size, tsk->comp->iax_output_size);
+
+			return -ENXIO;
+		}
+		if (rc) {
+			err("Decompress mismatch, memcmp rc %d\n", rc);
+			for (i = 0; i < (tsk->input_size / 4); i++) {
+				printf("Exp[%d]=0x%04X, Act[%d]=0x%04X\n",
+				       i, ((uint32_t *)tsk->input)[i],
+				       i, ((uint32_t *)tsk->dst1)[i]);
+			}
+
+			return -ENXIO;
+		}
+		return ACCTEST_STATUS_OK;
+	}
+
+	/* mismatch_expected */
+	if (rc) {
+		info("expected mismatch\n");
+		return ACCTEST_STATUS_OK;
+	}
+
+	return -ENXIO;
+}
diff --git a/test/iaa.h b/test/iaa.h
index 1e6010f..8166571 100644
--- a/test/iaa.h
+++ b/test/iaa.h
@@ -16,6 +16,7 @@ int iaa_zdecompress16_multi_task_nodes(struct acctest_context *ctx);
 int iaa_zcompress32_multi_task_nodes(struct acctest_context *ctx);
 int iaa_zdecompress32_multi_task_nodes(struct acctest_context *ctx);
 int iaa_compress_multi_task_nodes(struct acctest_context *ctx);
+int iaa_decompress_multi_task_nodes(struct acctest_context *ctx);
 
 void iaa_prep_noop(struct task *tsk);
 void iaa_prep_crc64(struct task *tsk);
@@ -24,6 +25,7 @@ void iaa_prep_zdecompress16(struct task *tsk);
 void iaa_prep_zcompress32(struct task *tsk);
 void iaa_prep_zdecompress32(struct task *tsk);
 void iaa_prep_compress(struct task *tsk);
+void iaa_prep_decompress(struct task *tsk);
 
 int iaa_task_result_verify(struct task *tsk, int mismatch_expected);
 int iaa_task_result_verify_task_nodes(struct acctest_context *ctx, int mismatch_expected);
@@ -33,5 +35,6 @@ int task_result_verify_zdecompress16(struct task *tsk, int mismatch_expected);
 int task_result_verify_zcompress32(struct task *tsk, int mismatch_expected);
 int task_result_verify_zdecompress32(struct task *tsk, int mismatch_expected);
 int task_result_verify_compress(struct task *tsk, int mismatch_expected);
+int task_result_verify_decompress(struct task *tsk, int mismatch_expected);
 
 #endif
diff --git a/test/iaa_prep.c b/test/iaa_prep.c
index 0d454ff..948bd23 100644
--- a/test/iaa_prep.c
+++ b/test/iaa_prep.c
@@ -89,3 +89,17 @@ void iaa_prep_compress(struct task *tsk)
 	tsk->desc->iax_max_dst_size = tsk->iaa_max_dst_size;
 	tsk->comp->status = 0;
 }
+
+void iaa_prep_decompress(struct task *tsk)
+{
+	info("preparing descriptor for decompress\n");
+
+	acctest_prep_desc_common(tsk->desc, tsk->opcode, (uint64_t)(tsk->dst1),
+				 (uint64_t)(tsk->src1), tsk->xfer_size, tsk->dflags);
+	tsk->desc->completion_addr = (uint64_t)(tsk->comp);
+	tsk->desc->iax_decompr_flags = tsk->iaa_decompr_flags;
+	tsk->desc->iax_src2_addr = (uint64_t)(tsk->src2);
+	tsk->desc->iax_src2_xfer_size = tsk->iaa_src2_xfer_size;
+	tsk->desc->iax_max_dst_size = tsk->iaa_max_dst_size;
+	tsk->comp->status = 0;
+}
diff --git a/test/iaa_test.c b/test/iaa_test.c
index 16bf363..5939a4b 100644
--- a/test/iaa_test.c
+++ b/test/iaa_test.c
@@ -263,6 +263,16 @@ static int test_compress(struct acctest_context *ctx, size_t buf_size, int tflag
 			if (rc != ACCTEST_STATUS_OK)
 				return rc;
 
+			/* Verification of all the nodes*/
+			rc = iaa_task_result_verify_task_nodes(ctx, 0);
+			if (rc != ACCTEST_STATUS_OK)
+				return rc;
+			break;
+		case IAX_OPCODE_DECOMPRESS:
+			rc = iaa_decompress_multi_task_nodes(ctx);
+			if (rc != ACCTEST_STATUS_OK)
+				return rc;
+
 			/* Verification of all the nodes*/
 			rc = iaa_task_result_verify_task_nodes(ctx, 0);
 			if (rc != ACCTEST_STATUS_OK)
@@ -375,6 +385,7 @@ int main(int argc, char *argv[])
 		break;
 
 	case IAX_OPCODE_COMPRESS:
+	case IAX_OPCODE_DECOMPRESS:
 		rc = test_compress(iaa, buf_size, tflags, extra_flags, opcode, num_desc);
 		if (rc != ACCTEST_STATUS_OK)
 			goto error;
-- 
2.25.1