[dpdk-dev] [PATCH 0/2] Add external mbufs option

[dpdk-dev] [PATCH 0/2] Add external mbufs option

[Adam Dybkowski]

This patchset adds a unit test of the external buffers
functionality and adds a new option to the compression
performance benchmark tool to use memzones as external
buffers instead of the data put directly inside mbufs.

Adam Dybkowski (2):
  test/compress: add external buffer in mbuf API test
  app/compress-perf: add external mbufs option

 app/test-compress-perf/comp_perf_options.h    |   2 +
 .../comp_perf_options_parse.c                 |  15 ++
 .../comp_perf_test_benchmark.c                |   3 +-
 .../comp_perf_test_common.c                   | 201 +++++++++++++-
 .../comp_perf_test_common.h                   |   9 +-
 .../comp_perf_test_verify.c                   |   4 +-
 app/test/test_compressdev.c                   | 245 ++++++++++++++----
 7 files changed, 416 insertions(+), 63 deletions(-)

-- 
2.17.1

[dpdk-dev] [PATCH 1/2] test/compress: add external buffer in mbuf API test

[Adam Dybkowski]

Adds a new test to verify external buffer in mbuf APIs.
Initialize fields in test_data_params structures by name
for better readability.

Signed-off-by: Adam Dybkowski <adamx.dybkowski@intel.com>
---
 app/test/test_compressdev.c | 245 ++++++++++++++++++++++++++++--------
 1 file changed, 194 insertions(+), 51 deletions(-)

diff --git a/app/test/test_compressdev.c b/app/test/test_compressdev.c
index 992eac8e0..31aafc427 100644
--- a/app/test/test_compressdev.c
+++ b/app/test/test_compressdev.c
@@ -100,6 +100,11 @@ struct test_data_params {
 	enum zlib_direction zlib_dir;
 	unsigned int out_of_space;
 	unsigned int big_data;
+	unsigned int use_external_mbufs;
+	unsigned int inbuf_data_size;
+	const struct rte_memzone *inbuf_memzone;
+	const struct rte_memzone *compbuf_memzone;
+	const struct rte_memzone *uncompbuf_memzone;
 };
 
 static struct comp_testsuite_params testsuite_params = { 0 };
@@ -710,6 +715,11 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf,
 	return 0;
 }
 
+static void
+extbuf_free_callback(void *addr __rte_unused, void *opaque __rte_unused)
+{
+}
+
 /*
  * Compresses and decompresses buffer with compressdev API and Zlib API
  */
@@ -729,6 +739,9 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	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;
+	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_status = -1;
 	int ret;
 	struct rte_mbuf *uncomp_bufs[num_bufs];
@@ -785,7 +798,20 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		goto exit;
 	}
 
-	if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
+	if (test_data->use_external_mbufs) {
+		inbuf_info.free_cb = extbuf_free_callback;
+		inbuf_info.fcb_opaque = NULL;
+		rte_mbuf_ext_refcnt_set(&inbuf_info, 1);
+		for (i = 0; i < num_bufs; i++) {
+			rte_pktmbuf_attach_extbuf(uncomp_bufs[i],
+					test_data->inbuf_memzone->addr,
+					test_data->inbuf_memzone->iova,
+					test_data->inbuf_data_size,
+					&inbuf_info);
+			rte_pktmbuf_append(uncomp_bufs[i],
+					test_data->inbuf_data_size);
+		}
+	} else if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
 		for (i = 0; i < num_bufs; i++) {
 			data_size = strlen(test_bufs[i]) + 1;
 			if (prepare_sgl_bufs(test_bufs[i], uncomp_bufs[i],
@@ -813,7 +839,20 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		goto exit;
 	}
 
-	if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
+	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) {
 		for (i = 0; i < num_bufs; i++) {
 			if (out_of_space == 1 && oos_zlib_decompress)
 				data_size = OUT_OF_SPACE_BUF;
@@ -1041,7 +1080,20 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		goto exit;
 	}
 
-	if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
+	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);
@@ -1265,8 +1317,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_bufs[priv_data->orig_idx];
+		const char *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 "
@@ -1276,7 +1333,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 
 		buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, 0,
 				ops_processed[i]->produced, contig_buf);
-		if (compare_buffers(buf1, strlen(buf1) + 1,
+		if (compare_buffers(buf1, data_size,
 				buf2, ops_processed[i]->produced) < 0)
 			goto exit;
 
@@ -1354,11 +1411,11 @@ test_compressdev_deflate_stateless_fixed(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		LB_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		0
+		.state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0
 	};
 
 	for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
@@ -1425,11 +1482,11 @@ test_compressdev_deflate_stateless_dynamic(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		LB_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		0
+		.state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0
 	};
 
 	for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
@@ -1479,11 +1536,11 @@ test_compressdev_deflate_stateless_multi_op(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		LB_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		0
+		.state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0
 	};
 
 	/* Compress with compressdev, decompress with Zlib */
@@ -1529,11 +1586,11 @@ test_compressdev_deflate_stateless_multi_level(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		LB_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		0
+		.state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0
 	};
 
 	for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
@@ -1619,11 +1676,11 @@ test_compressdev_deflate_stateless_multi_xform(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		LB_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		0
+		.state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0
 	};
 
 	/* Compress with compressdev, decompress with Zlib */
@@ -1665,11 +1722,11 @@ test_compressdev_deflate_stateless_sgl(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		SGL_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		0
+		.state = RTE_COMP_OP_STATELESS,
+		.buff_type = SGL_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0
 	};
 
 	for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
@@ -1773,11 +1830,11 @@ test_compressdev_deflate_stateless_checksum(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		LB_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		0
+		.state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0
 	};
 
 	/* Check if driver supports crc32 checksum and test */
@@ -1876,7 +1933,7 @@ test_compressdev_out_of_space_buffer(void)
 	uint16_t i;
 	const struct rte_compressdev_capabilities *capab;
 
-	RTE_LOG(ERR, USER1, "This is a negative test errors are expected\n");
+	RTE_LOG(ERR, USER1, "This is a negative test, errors are expected\n");
 
 	capab = rte_compressdev_capability_get(0, RTE_COMP_ALGO_DEFLATE);
 	TEST_ASSERT(capab != NULL, "Failed to retrieve device capabilities");
@@ -1904,11 +1961,11 @@ test_compressdev_out_of_space_buffer(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		LB_BOTH,
-		ZLIB_DECOMPRESS,
-		1,  /* run out-of-space test */
-		0
+		.state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 1,  /* run out-of-space test */
+		.big_data = 0
 	};
 	/* Compress with compressdev, decompress with Zlib */
 	test_data.zlib_dir = ZLIB_DECOMPRESS;
@@ -1985,11 +2042,11 @@ test_compressdev_deflate_stateless_dynamic_big(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		SGL_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		1
+		.state = RTE_COMP_OP_STATELESS,
+		.buff_type = SGL_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 1
 	};
 
 	ts_params->def_comp_xform->compress.deflate.huffman =
@@ -2022,6 +2079,90 @@ test_compressdev_deflate_stateless_dynamic_big(void)
 	return ret;
 }
 
+static const struct rte_memzone *
+make_memzone(const char *name, size_t size)
+{
+	unsigned int socket_id = rte_socket_id();
+	char mz_name[RTE_MEMZONE_NAMESIZE];
+	const struct rte_memzone *memzone;
+
+	snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "%s_%u", name, socket_id);
+	memzone = rte_memzone_lookup(mz_name);
+	if (memzone != NULL && memzone->len != size) {
+		rte_memzone_free(memzone);
+		memzone = NULL;
+	}
+	if (memzone == NULL) {
+		memzone = rte_memzone_reserve_aligned(mz_name, size, socket_id,
+				RTE_MEMZONE_IOVA_CONTIG, RTE_CACHE_LINE_SIZE);
+		if (memzone == NULL)
+			RTE_LOG(ERR, USER1, "Can't allocate memory zone %s",
+				mz_name);
+	}
+	return memzone;
+}
+
+static int
+test_compressdev_external_mbufs(void)
+{
+	struct comp_testsuite_params *ts_params = &testsuite_params;
+	size_t data_len = 0;
+	uint16_t i;
+	int ret = TEST_FAILED;
+
+	for (i = 0; i < RTE_DIM(compress_test_bufs); i++)
+		data_len = RTE_MAX(data_len, strlen(compress_test_bufs[i]) + 1);
+
+	struct interim_data_params int_data = {
+		NULL,
+		1,
+		NULL,
+		&ts_params->def_comp_xform,
+		&ts_params->def_decomp_xform,
+		1
+	};
+
+	struct test_data_params test_data = {
+		.state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0,
+		.use_external_mbufs = 1,
+		.inbuf_data_size = data_len,
+		.inbuf_memzone = make_memzone("inbuf", data_len),
+		.compbuf_memzone = make_memzone("compbuf", data_len *
+						COMPRESS_BUF_SIZE_RATIO),
+		.uncompbuf_memzone = make_memzone("decompbuf", data_len)
+	};
+
+	for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
+		/* prepare input data */
+		data_len = strlen(compress_test_bufs[i]) + 1;
+		rte_memcpy(test_data.inbuf_memzone->addr, compress_test_bufs[i],
+			   data_len);
+		test_data.inbuf_data_size = data_len;
+		int_data.buf_idx = &i;
+
+		/* Compress with compressdev, decompress with Zlib */
+		test_data.zlib_dir = ZLIB_DECOMPRESS;
+		if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
+			goto exit;
+
+		/* Compress with Zlib, decompress with compressdev */
+		test_data.zlib_dir = ZLIB_COMPRESS;
+		if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
+			goto exit;
+	}
+
+	ret = TEST_SUCCESS;
+
+exit:
+	rte_memzone_free(test_data.inbuf_memzone);
+	rte_memzone_free(test_data.compbuf_memzone);
+	rte_memzone_free(test_data.uncompbuf_memzone);
+	return ret;
+}
 
 static struct unit_test_suite compressdev_testsuite  = {
 	.suite_name = "compressdev unit test suite",
@@ -2048,6 +2189,8 @@ static struct unit_test_suite compressdev_testsuite  = {
 			test_compressdev_deflate_stateless_checksum),
 		TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
 			test_compressdev_out_of_space_buffer),
+		TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
+			test_compressdev_external_mbufs),
 		TEST_CASES_END() /**< NULL terminate unit test array */
 	}
 };
-- 
2.17.1

[dpdk-dev] [PATCH 2/2] app/compress-perf: add external mbufs option

[Adam Dybkowski]

This patch adds new performance measurement option --external-mbufs
that allocates and uses memzones as external buffers instead of
putting the data directly inside mbufs.

Signed-off-by: Adam Dybkowski <adamx.dybkowski@intel.com>
---
 app/test-compress-perf/comp_perf_options.h    |   2 +
 .../comp_perf_options_parse.c                 |  15 ++
 .../comp_perf_test_benchmark.c                |   3 +-
 .../comp_perf_test_common.c                   | 201 +++++++++++++++++-
 .../comp_perf_test_common.h                   |   9 +-
 .../comp_perf_test_verify.c                   |   4 +-
 6 files changed, 222 insertions(+), 12 deletions(-)

diff --git a/app/test-compress-perf/comp_perf_options.h b/app/test-compress-perf/comp_perf_options.h
index 651cbea4e..606268373 100644
--- a/app/test-compress-perf/comp_perf_options.h
+++ b/app/test-compress-perf/comp_perf_options.h
@@ -56,12 +56,14 @@ struct comp_test_data {
 	uint32_t pool_sz;
 	uint32_t num_iter;
 	uint16_t max_sgl_segs;
+	uint32_t total_segs;
 
 	enum rte_comp_huffman huffman_enc;
 	enum comp_operation test_op;
 	int window_sz;
 	struct range_list level_lst;
 	uint8_t level;
+	int use_external_mbufs;
 
 	double ratio;
 	enum cleanup_st cleanup;
diff --git a/app/test-compress-perf/comp_perf_options_parse.c b/app/test-compress-perf/comp_perf_options_parse.c
index 01e19eafb..e623fea7f 100644
--- a/app/test-compress-perf/comp_perf_options_parse.c
+++ b/app/test-compress-perf/comp_perf_options_parse.c
@@ -28,6 +28,7 @@
 #define CPERF_HUFFMAN_ENC	("huffman-enc")
 #define CPERF_LEVEL		("compress-level")
 #define CPERF_WINDOW_SIZE	("window-sz")
+#define CPERF_EXTERNAL_MBUFS	("external-mbufs")
 
 struct name_id_map {
 	const char *name;
@@ -58,6 +59,8 @@ usage(char *progname)
 		"		(default: range between 1 and 9)\n"
 		" --window-sz N: base two log value of compression window size\n"
 		"		(e.g.: 15 => 32k, default: max supported by PMD)\n"
+		" --external-mbufs: use memzones as external buffers instead of\n"
+		"		keeping the data directly in mbuf area\n"
 		" -h: prints this help\n",
 		progname);
 }
@@ -520,6 +523,14 @@ parse_level(struct comp_test_data *test_data, const char *arg)
 	return 0;
 }
 
+static int
+parse_external_mbufs(struct comp_test_data *test_data,
+		     const char *arg __rte_unused)
+{
+	test_data->use_external_mbufs = 1;
+	return 0;
+}
+
 typedef int (*option_parser_t)(struct comp_test_data *test_data,
 		const char *arg);
 
@@ -544,8 +555,10 @@ static struct option lgopts[] = {
 	{ CPERF_HUFFMAN_ENC, required_argument, 0, 0 },
 	{ CPERF_LEVEL, required_argument, 0, 0 },
 	{ CPERF_WINDOW_SIZE, required_argument, 0, 0 },
+	{ CPERF_EXTERNAL_MBUFS, 0, 0, 0 },
 	{ NULL, 0, 0, 0 }
 };
+
 static int
 comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data)
 {
@@ -563,6 +576,7 @@ comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data)
 		{ CPERF_HUFFMAN_ENC,	parse_huffman_enc },
 		{ CPERF_LEVEL,		parse_level },
 		{ CPERF_WINDOW_SIZE,	parse_window_sz },
+		{ CPERF_EXTERNAL_MBUFS,	parse_external_mbufs },
 	};
 	unsigned int i;
 
@@ -618,6 +632,7 @@ comp_perf_options_default(struct comp_test_data *test_data)
 	test_data->level_lst.max = RTE_COMP_LEVEL_MAX;
 	test_data->level_lst.inc = 1;
 	test_data->test = CPERF_TEST_TYPE_BENCHMARK;
+	test_data->use_external_mbufs = 0;
 }
 
 int
diff --git a/app/test-compress-perf/comp_perf_test_benchmark.c b/app/test-compress-perf/comp_perf_test_benchmark.c
index 887459449..0c6bb9b45 100644
--- a/app/test-compress-perf/comp_perf_test_benchmark.c
+++ b/app/test-compress-perf/comp_perf_test_benchmark.c
@@ -15,7 +15,8 @@ cperf_benchmark_test_destructor(void *arg)
 {
 	if (arg) {
 		comp_perf_free_memory(
-				&((struct cperf_benchmark_ctx *)arg)->ver.mem);
+			((struct cperf_benchmark_ctx *)arg)->ver.options,
+			&((struct cperf_benchmark_ctx *)arg)->ver.mem);
 		rte_free(arg);
 	}
 }
diff --git a/app/test-compress-perf/comp_perf_test_common.c b/app/test-compress-perf/comp_perf_test_common.c
index 6edc40f04..80683c3a8 100644
--- a/app/test-compress-perf/comp_perf_test_common.c
+++ b/app/test-compress-perf/comp_perf_test_common.c
@@ -77,7 +77,8 @@ find_buf_size(uint32_t input_size)
 }
 
 void
-comp_perf_free_memory(struct cperf_mem_resources *mem)
+comp_perf_free_memory(struct comp_test_data *test_data,
+		      struct cperf_mem_resources *mem)
 {
 	uint32_t i;
 
@@ -93,26 +94,162 @@ comp_perf_free_memory(struct cperf_mem_resources *mem)
 	rte_mempool_free(mem->op_pool);
 	rte_mempool_free(mem->decomp_buf_pool);
 	rte_mempool_free(mem->comp_buf_pool);
+
+	/* external mbuf support */
+	if (mem->decomp_memzones != NULL) {
+		for (i = 0; i < test_data->total_segs; i++)
+			rte_memzone_free(mem->decomp_memzones[i]);
+		rte_free(mem->decomp_memzones);
+	}
+	if (mem->comp_memzones != NULL) {
+		for (i = 0; i < test_data->total_segs; i++)
+			rte_memzone_free(mem->comp_memzones[i]);
+		rte_free(mem->comp_memzones);
+	}
+	rte_free(mem->decomp_buf_infos);
+	rte_free(mem->comp_buf_infos);
+}
+
+static void
+comp_perf_extbuf_free_cb(void *addr __rte_unused, void *opaque __rte_unused)
+{
+}
+
+static const struct rte_memzone *
+comp_perf_make_memzone(const char *name, struct cperf_mem_resources *mem,
+		       unsigned int number, size_t size)
+{
+	unsigned int socket_id = rte_socket_id();
+	char mz_name[RTE_MEMZONE_NAMESIZE];
+	const struct rte_memzone *memzone;
+
+	snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "%s_s%u_d%u_q%u_%d", name,
+		 socket_id, mem->dev_id, mem->qp_id, number);
+	memzone = rte_memzone_lookup(mz_name);
+	if (memzone != NULL && memzone->len != size) {
+		rte_memzone_free(memzone);
+		memzone = NULL;
+	}
+	if (memzone == NULL) {
+		memzone = rte_memzone_reserve_aligned(mz_name, size, socket_id,
+				RTE_MEMZONE_IOVA_CONTIG, RTE_CACHE_LINE_SIZE);
+		if (memzone == NULL)
+			RTE_LOG(ERR, USER1, "Can't allocate memory zone %s\n",
+				mz_name);
+	}
+	return memzone;
+}
+
+static int
+comp_perf_allocate_external_mbufs(struct comp_test_data *test_data,
+				  struct cperf_mem_resources *mem)
+{
+	uint32_t i;
+
+	mem->comp_memzones = rte_zmalloc_socket(NULL,
+		test_data->total_segs * sizeof(struct rte_memzone *),
+		0, rte_socket_id());
+
+	if (mem->comp_memzones == NULL) {
+		RTE_LOG(ERR, USER1,
+			"Memory to hold the compression memzones could not be allocated\n");
+		return -1;
+	}
+
+	mem->decomp_memzones = rte_zmalloc_socket(NULL,
+		test_data->total_segs * sizeof(struct rte_memzone *),
+		0, rte_socket_id());
+
+	if (mem->decomp_memzones == NULL) {
+		RTE_LOG(ERR, USER1,
+			"Memory to hold the decompression memzones could not be allocated\n");
+		return -1;
+	}
+
+	mem->comp_buf_infos = rte_zmalloc_socket(NULL,
+		test_data->total_segs * sizeof(struct rte_mbuf_ext_shared_info),
+		0, rte_socket_id());
+
+	if (mem->comp_buf_infos == NULL) {
+		RTE_LOG(ERR, USER1,
+			"Memory to hold the compression buf infos could not be allocated\n");
+		return -1;
+	}
+
+	mem->decomp_buf_infos = rte_zmalloc_socket(NULL,
+		test_data->total_segs * sizeof(struct rte_mbuf_ext_shared_info),
+		0, rte_socket_id());
+
+	if (mem->decomp_buf_infos == NULL) {
+		RTE_LOG(ERR, USER1,
+			"Memory to hold the decompression buf infos could not be allocated\n");
+		return -1;
+	}
+
+	for (i = 0; i < test_data->total_segs; i++) {
+		mem->comp_memzones[i] = comp_perf_make_memzone("comp", mem,
+				i, test_data->out_seg_sz);
+		if (mem->comp_memzones[i] == NULL) {
+			RTE_LOG(ERR, USER1,
+				"Memory to hold the compression memzone could not be allocated\n");
+			return -1;
+		}
+
+		mem->decomp_memzones[i] = comp_perf_make_memzone("decomp", mem,
+				i, test_data->seg_sz);
+		if (mem->decomp_memzones[i] == NULL) {
+			RTE_LOG(ERR, USER1,
+				"Memory to hold the decompression memzone could not be allocated\n");
+			return -1;
+		}
+
+		mem->comp_buf_infos[i].free_cb =
+				comp_perf_extbuf_free_cb;
+		mem->comp_buf_infos[i].fcb_opaque = NULL;
+		rte_mbuf_ext_refcnt_set(&mem->comp_buf_infos[i], 1);
+
+		mem->decomp_buf_infos[i].free_cb =
+				comp_perf_extbuf_free_cb;
+		mem->decomp_buf_infos[i].fcb_opaque = NULL;
+		rte_mbuf_ext_refcnt_set(&mem->decomp_buf_infos[i], 1);
+	}
+
+	return 0;
 }
 
 int
 comp_perf_allocate_memory(struct comp_test_data *test_data,
 			  struct cperf_mem_resources *mem)
 {
+	uint16_t comp_mbuf_size;
+	uint16_t decomp_mbuf_size;
+
 	test_data->out_seg_sz = find_buf_size(test_data->seg_sz);
+
 	/* Number of segments for input and output
 	 * (compression and decompression)
 	 */
-	uint32_t total_segs = DIV_CEIL(test_data->input_data_sz,
+	test_data->total_segs = DIV_CEIL(test_data->input_data_sz,
 			test_data->seg_sz);
+
+	if (test_data->use_external_mbufs != 0) {
+		if (comp_perf_allocate_external_mbufs(test_data, mem) < 0)
+			return -1;
+		comp_mbuf_size = 0;
+		decomp_mbuf_size = 0;
+	} else {
+		comp_mbuf_size = test_data->out_seg_sz + RTE_PKTMBUF_HEADROOM;
+		decomp_mbuf_size = test_data->seg_sz + RTE_PKTMBUF_HEADROOM;
+	}
+
 	char pool_name[32] = "";
 
 	snprintf(pool_name, sizeof(pool_name), "comp_buf_pool_%u_qp_%u",
 			mem->dev_id, mem->qp_id);
 	mem->comp_buf_pool = rte_pktmbuf_pool_create(pool_name,
-				total_segs,
+				test_data->total_segs,
 				0, 0,
-				test_data->out_seg_sz + RTE_PKTMBUF_HEADROOM,
+				comp_mbuf_size,
 				rte_socket_id());
 	if (mem->comp_buf_pool == NULL) {
 		RTE_LOG(ERR, USER1, "Mbuf mempool could not be created\n");
@@ -122,15 +259,17 @@ comp_perf_allocate_memory(struct comp_test_data *test_data,
 	snprintf(pool_name, sizeof(pool_name), "decomp_buf_pool_%u_qp_%u",
 			mem->dev_id, mem->qp_id);
 	mem->decomp_buf_pool = rte_pktmbuf_pool_create(pool_name,
-				total_segs,
-				0, 0, test_data->seg_sz + RTE_PKTMBUF_HEADROOM,
+				test_data->total_segs,
+				0, 0,
+				decomp_mbuf_size,
 				rte_socket_id());
 	if (mem->decomp_buf_pool == NULL) {
 		RTE_LOG(ERR, USER1, "Mbuf mempool could not be created\n");
 		return -1;
 	}
 
-	mem->total_bufs = DIV_CEIL(total_segs, test_data->max_sgl_segs);
+	mem->total_bufs = DIV_CEIL(test_data->total_segs,
+				   test_data->max_sgl_segs);
 
 	snprintf(pool_name, sizeof(pool_name), "op_pool_%u_qp_%u",
 			mem->dev_id, mem->qp_id);
@@ -148,7 +287,8 @@ comp_perf_allocate_memory(struct comp_test_data *test_data,
 	 */
 	mem->compressed_data = rte_zmalloc_socket(NULL,
 				RTE_MAX(
-				    (size_t) test_data->out_seg_sz * total_segs,
+				    (size_t) test_data->out_seg_sz *
+							  test_data->total_segs,
 				    (size_t) MIN_COMPRESSED_BUF_SIZE),
 				0,
 				rte_socket_id());
@@ -185,7 +325,7 @@ comp_perf_allocate_memory(struct comp_test_data *test_data,
 		return -1;
 	}
 
-	buffer_info.total_segments = total_segs;
+	buffer_info.total_segments = test_data->total_segs;
 	buffer_info.segment_sz = test_data->seg_sz;
 	buffer_info.total_buffs = mem->total_bufs;
 	buffer_info.segments_per_buff = test_data->max_sgl_segs;
@@ -203,6 +343,8 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
 	uint8_t *data_addr;
 	uint32_t i, j;
 	uint16_t segs_per_mbuf = 0;
+	uint32_t cmz = 0;
+	uint32_t dmz = 0;
 
 	for (i = 0; i < mem->total_bufs; i++) {
 		/* Allocate data in input mbuf and copy data from input file */
@@ -214,6 +356,16 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
 		}
 
 		data_sz = RTE_MIN(remaining_data, test_data->seg_sz);
+
+		if (test_data->use_external_mbufs != 0) {
+			rte_pktmbuf_attach_extbuf(mem->decomp_bufs[i],
+					mem->decomp_memzones[dmz]->addr,
+					mem->decomp_memzones[dmz]->iova,
+					test_data->seg_sz,
+					&mem->decomp_buf_infos[dmz]);
+			dmz++;
+		}
+
 		data_addr = (uint8_t *) rte_pktmbuf_append(
 					mem->decomp_bufs[i], data_sz);
 		if (data_addr == NULL) {
@@ -241,6 +393,17 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
 			}
 
 			data_sz = RTE_MIN(remaining_data, test_data->seg_sz);
+
+			if (test_data->use_external_mbufs != 0) {
+				rte_pktmbuf_attach_extbuf(
+					next_seg,
+					mem->decomp_memzones[dmz]->addr,
+					mem->decomp_memzones[dmz]->iova,
+					test_data->seg_sz,
+					&mem->decomp_buf_infos[dmz]);
+				dmz++;
+			}
+
 			data_addr = (uint8_t *)rte_pktmbuf_append(next_seg,
 				data_sz);
 
@@ -268,6 +431,16 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
 			RTE_LOG(ERR, USER1, "Could not allocate mbuf\n");
 			return -1;
 		}
+
+		if (test_data->use_external_mbufs != 0) {
+			rte_pktmbuf_attach_extbuf(mem->comp_bufs[i],
+					mem->comp_memzones[cmz]->addr,
+					mem->comp_memzones[cmz]->iova,
+					test_data->out_seg_sz,
+					&mem->comp_buf_infos[cmz]);
+			cmz++;
+		}
+
 		data_addr = (uint8_t *) rte_pktmbuf_append(
 					mem->comp_bufs[i],
 					test_data->out_seg_sz);
@@ -287,6 +460,16 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
 				return -1;
 			}
 
+			if (test_data->use_external_mbufs != 0) {
+				rte_pktmbuf_attach_extbuf(
+					next_seg,
+					mem->comp_memzones[cmz]->addr,
+					mem->comp_memzones[cmz]->iova,
+					test_data->out_seg_sz,
+					&mem->comp_buf_infos[cmz]);
+				cmz++;
+			}
+
 			data_addr = (uint8_t *)rte_pktmbuf_append(next_seg,
 				test_data->out_seg_sz);
 			if (data_addr == NULL) {
diff --git a/app/test-compress-perf/comp_perf_test_common.h b/app/test-compress-perf/comp_perf_test_common.h
index c9e0c9081..920642888 100644
--- a/app/test-compress-perf/comp_perf_test_common.h
+++ b/app/test-compress-perf/comp_perf_test_common.h
@@ -26,13 +26,20 @@ struct cperf_mem_resources {
 	struct rte_mempool *comp_buf_pool;
 	struct rte_mempool *decomp_buf_pool;
 	struct rte_mempool *op_pool;
+
+	/* external mbuf support */
+	const struct rte_memzone **comp_memzones;
+	const struct rte_memzone **decomp_memzones;
+	struct rte_mbuf_ext_shared_info *comp_buf_infos;
+	struct rte_mbuf_ext_shared_info *decomp_buf_infos;
 };
 
 int
 param_range_check(uint16_t size, const struct rte_param_log2_range *range);
 
 void
-comp_perf_free_memory(struct cperf_mem_resources *mem);
+comp_perf_free_memory(struct comp_test_data *test_data,
+		      struct cperf_mem_resources *mem);
 
 int
 comp_perf_allocate_memory(struct comp_test_data *test_data,
diff --git a/app/test-compress-perf/comp_perf_test_verify.c b/app/test-compress-perf/comp_perf_test_verify.c
index f66f95ff7..758a22ff5 100644
--- a/app/test-compress-perf/comp_perf_test_verify.c
+++ b/app/test-compress-perf/comp_perf_test_verify.c
@@ -14,7 +14,9 @@ void
 cperf_verify_test_destructor(void *arg)
 {
 	if (arg) {
-		comp_perf_free_memory(&((struct cperf_verify_ctx *)arg)->mem);
+		comp_perf_free_memory(
+				((struct cperf_verify_ctx *)arg)->options,
+				&((struct cperf_verify_ctx *)arg)->mem);
 		rte_free(arg);
 	}
 }
-- 
2.17.1

Re: [dpdk-dev] [PATCH 2/2] app/compress-perf: add external mbufs option

[Trahe, Fiona]

> -----Original Message-----
> From: Dybkowski, AdamX
> Sent: Tuesday, September 3, 2019 10:43 AM
> To: dev@dpdk.org; Trahe, Fiona <fiona.trahe@intel.com>; De Lara Guarch, Pablo
> <pablo.de.lara.guarch@intel.com>; Trybula, ArturX <arturx.trybula@intel.com>
> Cc: Dybkowski, AdamX <adamx.dybkowski@intel.com>
> Subject: [PATCH 2/2] app/compress-perf: add external mbufs option
> 
> This patch adds new performance measurement option --external-mbufs
> that allocates and uses memzones as external buffers instead of
> putting the data directly inside mbufs.
> 
> Signed-off-by: Adam Dybkowski <adamx.dybkowski@intel.com>
Acked-by: Fiona Trahe <fiona.trahe@intel.com>

Re: [dpdk-dev] [PATCH 1/2] test/compress: add external buffer in mbuf API test

[Trahe, Fiona]

> -----Original Message-----
> From: Dybkowski, AdamX
> Sent: Tuesday, September 3, 2019 10:43 AM
> To: dev@dpdk.org; Trahe, Fiona <fiona.trahe@intel.com>; De Lara Guarch, Pablo
> <pablo.de.lara.guarch@intel.com>; Trybula, ArturX <arturx.trybula@intel.com>
> Cc: Dybkowski, AdamX <adamx.dybkowski@intel.com>
> Subject: [PATCH 1/2] test/compress: add external buffer in mbuf API test
> 
> Adds a new test to verify external buffer in mbuf APIs.
> Initialize fields in test_data_params structures by name
> for better readability.
> 
> Signed-off-by: Adam Dybkowski <adamx.dybkowski@intel.com>
Acked-by: Fiona Trahe <fiona.trahe@intel.com>

[dpdk-dev] [PATCH v2 0/2] Add external mbufs option

[Adam Dybkowski]

This patchset adds a unit test of the external buffers
functionality and a new option to the compression
performance benchmark tool to use memzones as external
buffers instead of the data put directly inside mbufs.
---
v2:
* Rebasing over the stateful decompression patch

This patch depends on https://patches.dpdk.org/cover/59610/

Adam Dybkowski (2):
  test/compress: add external buffer in mbuf API test
  app/compress-perf: add external mbufs option

 app/test-compress-perf/comp_perf_options.h    |   2 +
 .../comp_perf_options_parse.c                 |  15 +
 .../comp_perf_test_benchmark.c                |   3 +-
 .../comp_perf_test_common.c                   | 201 ++++++++++-
 .../comp_perf_test_common.h                   |   9 +-
 .../comp_perf_test_verify.c                   |   4 +-
 app/test/test_compressdev.c                   | 314 ++++++++++++------
 7 files changed, 443 insertions(+), 105 deletions(-)

-- 
2.17.1

[dpdk-dev] [PATCH v2 1/2] test/compress: add external buffer in mbuf API test

[Adam Dybkowski]

Adds a new test to verify external buffer in mbuf APIs.
Initialize fields in test_data_params structures by name
for better readability.

Signed-off-by: Adam Dybkowski <adamx.dybkowski@intel.com>
---
 app/test/test_compressdev.c | 314 +++++++++++++++++++++++++-----------
 1 file changed, 221 insertions(+), 93 deletions(-)

diff --git a/app/test/test_compressdev.c b/app/test/test_compressdev.c
index 9a7989683..d470c34b9 100644
--- a/app/test/test_compressdev.c
+++ b/app/test/test_compressdev.c
@@ -104,6 +104,12 @@ struct test_data_params {
 	/* stateful decompression specific parameters */
 	unsigned int decompress_output_block_size;
 	unsigned int decompress_steps_max;
+	/* external mbufs specific parameters */
+	unsigned int use_external_mbufs;
+	unsigned int inbuf_data_size;
+	const struct rte_memzone *inbuf_memzone;
+	const struct rte_memzone *compbuf_memzone;
+	const struct rte_memzone *uncompbuf_memzone;
 };
 
 static struct comp_testsuite_params testsuite_params = { 0 };
@@ -714,6 +720,11 @@ prepare_sgl_bufs(const char *test_buf, struct rte_mbuf *head_buf,
 	return 0;
 }
 
+static void
+extbuf_free_callback(void *addr __rte_unused, void *opaque __rte_unused)
+{
+}
+
 /*
  * Compresses and decompresses buffer with compressdev API and Zlib API
  */
@@ -735,6 +746,9 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 	unsigned int big_data = test_data->big_data;
 	enum zlib_direction zlib_dir = test_data->zlib_dir;
 	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];
@@ -803,7 +817,20 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		goto exit;
 	}
 
-	if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
+	if (test_data->use_external_mbufs) {
+		inbuf_info.free_cb = extbuf_free_callback;
+		inbuf_info.fcb_opaque = NULL;
+		rte_mbuf_ext_refcnt_set(&inbuf_info, 1);
+		for (i = 0; i < num_bufs; i++) {
+			rte_pktmbuf_attach_extbuf(uncomp_bufs[i],
+					test_data->inbuf_memzone->addr,
+					test_data->inbuf_memzone->iova,
+					test_data->inbuf_data_size,
+					&inbuf_info);
+			rte_pktmbuf_append(uncomp_bufs[i],
+					test_data->inbuf_data_size);
+		}
+	} else if (buff_type == SGL_BOTH || buff_type == SGL_TO_LB) {
 		for (i = 0; i < num_bufs; i++) {
 			data_size = strlen(test_bufs[i]) + 1;
 			if (prepare_sgl_bufs(test_bufs[i], uncomp_bufs[i],
@@ -831,7 +858,20 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		goto exit;
 	}
 
-	if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
+	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) {
 		for (i = 0; i < num_bufs; i++) {
 			if (out_of_space == 1 && oos_zlib_decompress)
 				data_size = OUT_OF_SPACE_BUF;
@@ -1058,7 +1098,20 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 		goto exit;
 	}
 
-	if (buff_type == SGL_BOTH || buff_type == LB_TO_SGL) {
+	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);
@@ -1386,8 +1439,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_bufs[priv_data->orig_idx];
+		const char *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 "
@@ -1397,7 +1455,7 @@ test_deflate_comp_decomp(const struct interim_data_params *int_data,
 
 		buf2 = rte_pktmbuf_read(ops_processed[i]->m_dst, 0,
 				ops_processed[i]->produced, contig_buf);
-		if (compare_buffers(buf1, strlen(buf1) + 1,
+		if (compare_buffers(buf1, data_size,
 				buf2, ops_processed[i]->produced) < 0)
 			goto exit;
 
@@ -1478,14 +1536,12 @@ test_compressdev_deflate_stateless_fixed(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		RTE_COMP_OP_STATELESS,
-		LB_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		0,
-		0,
-		0
+		.compress_state = RTE_COMP_OP_STATELESS,
+		.decompress_state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0
 	};
 
 	for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
@@ -1550,14 +1606,12 @@ test_compressdev_deflate_stateless_dynamic(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		RTE_COMP_OP_STATELESS,
-		LB_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		0,
-		0,
-		0
+		.compress_state = RTE_COMP_OP_STATELESS,
+		.decompress_state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0
 	};
 
 	for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
@@ -1606,14 +1660,12 @@ test_compressdev_deflate_stateless_multi_op(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		RTE_COMP_OP_STATELESS,
-		LB_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		0,
-		0,
-		0
+		.compress_state = RTE_COMP_OP_STATELESS,
+		.decompress_state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0
 	};
 
 	/* Compress with compressdev, decompress with Zlib */
@@ -1661,14 +1713,12 @@ test_compressdev_deflate_stateless_multi_level(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		RTE_COMP_OP_STATELESS,
-		LB_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		0,
-		0,
-		0
+		.compress_state = RTE_COMP_OP_STATELESS,
+		.decompress_state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0
 	};
 
 	for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
@@ -1752,14 +1802,12 @@ test_compressdev_deflate_stateless_multi_xform(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		RTE_COMP_OP_STATELESS,
-		LB_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		0,
-		0,
-		0
+		.compress_state = RTE_COMP_OP_STATELESS,
+		.decompress_state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0
 	};
 
 	/* Compress with compressdev, decompress with Zlib */
@@ -1802,14 +1850,12 @@ test_compressdev_deflate_stateless_sgl(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		RTE_COMP_OP_STATELESS,
-		SGL_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		0,
-		0,
-		0
+		.compress_state = RTE_COMP_OP_STATELESS,
+		.decompress_state = RTE_COMP_OP_STATELESS,
+		.buff_type = SGL_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0
 	};
 
 	for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
@@ -1914,14 +1960,12 @@ test_compressdev_deflate_stateless_checksum(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		RTE_COMP_OP_STATELESS,
-		LB_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		0,
-		0,
-		0
+		.compress_state = RTE_COMP_OP_STATELESS,
+		.decompress_state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0
 	};
 
 	/* Check if driver supports crc32 checksum and test */
@@ -2033,14 +2077,12 @@ test_compressdev_out_of_space_buffer(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		RTE_COMP_OP_STATELESS,
-		LB_BOTH,
-		ZLIB_DECOMPRESS,
-		1,  /* run out-of-space test */
-		0,
-		0,
-		0
+		.compress_state = RTE_COMP_OP_STATELESS,
+		.decompress_state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 1,  /* run out-of-space test */
+		.big_data = 0
 	};
 	/* Compress with compressdev, decompress with Zlib */
 	test_data.zlib_dir = ZLIB_DECOMPRESS;
@@ -2112,14 +2154,12 @@ test_compressdev_deflate_stateless_dynamic_big(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		RTE_COMP_OP_STATELESS,
-		SGL_BOTH,
-		ZLIB_DECOMPRESS,
-		0,
-		1,
-		0,
-		0
+		.compress_state = RTE_COMP_OP_STATELESS,
+		.decompress_state = RTE_COMP_OP_STATELESS,
+		.buff_type = SGL_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 1
 	};
 
 	ts_params->def_comp_xform->compress.deflate.huffman =
@@ -2176,14 +2216,14 @@ test_compressdev_deflate_stateful_decomp(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		RTE_COMP_OP_STATEFUL,
-		LB_BOTH,
-		ZLIB_COMPRESS,
-		0,
-		0,
-		2000,
-		4
+		.compress_state = RTE_COMP_OP_STATELESS,
+		.decompress_state = RTE_COMP_OP_STATEFUL,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_COMPRESS,
+		.out_of_space = 0,
+		.big_data = 0,
+		.decompress_output_block_size = 2000,
+		.decompress_steps_max = 4
 	};
 
 	/* Compress with Zlib, decompress with compressdev */
@@ -2258,14 +2298,14 @@ test_compressdev_deflate_stateful_decomp_checksum(void)
 	};
 
 	struct test_data_params test_data = {
-		RTE_COMP_OP_STATELESS,
-		RTE_COMP_OP_STATEFUL,
-		LB_BOTH,
-		ZLIB_COMPRESS,
-		0,
-		0,
-		2000,
-		4
+		.compress_state = RTE_COMP_OP_STATELESS,
+		.decompress_state = RTE_COMP_OP_STATEFUL,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_COMPRESS,
+		.out_of_space = 0,
+		.big_data = 0,
+		.decompress_output_block_size = 2000,
+		.decompress_steps_max = 4
 	};
 
 	/* Check if driver supports crc32 checksum and test */
@@ -2346,6 +2386,92 @@ test_compressdev_deflate_stateful_decomp_checksum(void)
 	return ret;
 }
 
+static const struct rte_memzone *
+make_memzone(const char *name, size_t size)
+{
+	unsigned int socket_id = rte_socket_id();
+	char mz_name[RTE_MEMZONE_NAMESIZE];
+	const struct rte_memzone *memzone;
+
+	snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "%s_%u", name, socket_id);
+	memzone = rte_memzone_lookup(mz_name);
+	if (memzone != NULL && memzone->len != size) {
+		rte_memzone_free(memzone);
+		memzone = NULL;
+	}
+	if (memzone == NULL) {
+		memzone = rte_memzone_reserve_aligned(mz_name, size, socket_id,
+				RTE_MEMZONE_IOVA_CONTIG, RTE_CACHE_LINE_SIZE);
+		if (memzone == NULL)
+			RTE_LOG(ERR, USER1, "Can't allocate memory zone %s",
+				mz_name);
+	}
+	return memzone;
+}
+
+static int
+test_compressdev_external_mbufs(void)
+{
+	struct comp_testsuite_params *ts_params = &testsuite_params;
+	size_t data_len = 0;
+	uint16_t i;
+	int ret = TEST_FAILED;
+
+	for (i = 0; i < RTE_DIM(compress_test_bufs); i++)
+		data_len = RTE_MAX(data_len, strlen(compress_test_bufs[i]) + 1);
+
+	struct interim_data_params int_data = {
+		NULL,
+		1,
+		NULL,
+		&ts_params->def_comp_xform,
+		&ts_params->def_decomp_xform,
+		1
+	};
+
+	struct test_data_params test_data = {
+		.compress_state = RTE_COMP_OP_STATELESS,
+		.decompress_state = RTE_COMP_OP_STATELESS,
+		.buff_type = LB_BOTH,
+		.zlib_dir = ZLIB_DECOMPRESS,
+		.out_of_space = 0,
+		.big_data = 0,
+		.use_external_mbufs = 1,
+		.inbuf_data_size = data_len,
+		.inbuf_memzone = make_memzone("inbuf", data_len),
+		.compbuf_memzone = make_memzone("compbuf", data_len *
+						COMPRESS_BUF_SIZE_RATIO),
+		.uncompbuf_memzone = make_memzone("decompbuf", data_len)
+	};
+
+	for (i = 0; i < RTE_DIM(compress_test_bufs); i++) {
+		/* prepare input data */
+		data_len = strlen(compress_test_bufs[i]) + 1;
+		rte_memcpy(test_data.inbuf_memzone->addr, compress_test_bufs[i],
+			   data_len);
+		test_data.inbuf_data_size = data_len;
+		int_data.buf_idx = &i;
+
+		/* Compress with compressdev, decompress with Zlib */
+		test_data.zlib_dir = ZLIB_DECOMPRESS;
+		if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
+			goto exit;
+
+		/* Compress with Zlib, decompress with compressdev */
+		test_data.zlib_dir = ZLIB_COMPRESS;
+		if (test_deflate_comp_decomp(&int_data, &test_data) < 0)
+			goto exit;
+	}
+
+	ret = TEST_SUCCESS;
+
+exit:
+	rte_memzone_free(test_data.inbuf_memzone);
+	rte_memzone_free(test_data.compbuf_memzone);
+	rte_memzone_free(test_data.uncompbuf_memzone);
+	return ret;
+}
+
 static struct unit_test_suite compressdev_testsuite  = {
 	.suite_name = "compressdev unit test suite",
 	.setup = testsuite_setup,
@@ -2375,6 +2501,8 @@ static struct unit_test_suite compressdev_testsuite  = {
 			test_compressdev_deflate_stateful_decomp),
 		TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
 			test_compressdev_deflate_stateful_decomp_checksum),
+		TEST_CASE_ST(generic_ut_setup, generic_ut_teardown,
+			test_compressdev_external_mbufs),
 		TEST_CASES_END() /**< NULL terminate unit test array */
 	}
 };
-- 
2.17.1

[dpdk-dev] [PATCH v2 2/2] app/compress-perf: add external mbufs option

[Adam Dybkowski]

This patch adds new performance measurement option --external-mbufs
that allocates and uses memzones as external buffers instead of
putting the data directly inside mbufs.

Signed-off-by: Adam Dybkowski <adamx.dybkowski@intel.com>
---
 app/test-compress-perf/comp_perf_options.h    |   2 +
 .../comp_perf_options_parse.c                 |  15 ++
 .../comp_perf_test_benchmark.c                |   3 +-
 .../comp_perf_test_common.c                   | 201 +++++++++++++++++-
 .../comp_perf_test_common.h                   |   9 +-
 .../comp_perf_test_verify.c                   |   4 +-
 6 files changed, 222 insertions(+), 12 deletions(-)

diff --git a/app/test-compress-perf/comp_perf_options.h b/app/test-compress-perf/comp_perf_options.h
index 651cbea4e..606268373 100644
--- a/app/test-compress-perf/comp_perf_options.h
+++ b/app/test-compress-perf/comp_perf_options.h
@@ -56,12 +56,14 @@ struct comp_test_data {
 	uint32_t pool_sz;
 	uint32_t num_iter;
 	uint16_t max_sgl_segs;
+	uint32_t total_segs;
 
 	enum rte_comp_huffman huffman_enc;
 	enum comp_operation test_op;
 	int window_sz;
 	struct range_list level_lst;
 	uint8_t level;
+	int use_external_mbufs;
 
 	double ratio;
 	enum cleanup_st cleanup;
diff --git a/app/test-compress-perf/comp_perf_options_parse.c b/app/test-compress-perf/comp_perf_options_parse.c
index 01e19eafb..e623fea7f 100644
--- a/app/test-compress-perf/comp_perf_options_parse.c
+++ b/app/test-compress-perf/comp_perf_options_parse.c
@@ -28,6 +28,7 @@
 #define CPERF_HUFFMAN_ENC	("huffman-enc")
 #define CPERF_LEVEL		("compress-level")
 #define CPERF_WINDOW_SIZE	("window-sz")
+#define CPERF_EXTERNAL_MBUFS	("external-mbufs")
 
 struct name_id_map {
 	const char *name;
@@ -58,6 +59,8 @@ usage(char *progname)
 		"		(default: range between 1 and 9)\n"
 		" --window-sz N: base two log value of compression window size\n"
 		"		(e.g.: 15 => 32k, default: max supported by PMD)\n"
+		" --external-mbufs: use memzones as external buffers instead of\n"
+		"		keeping the data directly in mbuf area\n"
 		" -h: prints this help\n",
 		progname);
 }
@@ -520,6 +523,14 @@ parse_level(struct comp_test_data *test_data, const char *arg)
 	return 0;
 }
 
+static int
+parse_external_mbufs(struct comp_test_data *test_data,
+		     const char *arg __rte_unused)
+{
+	test_data->use_external_mbufs = 1;
+	return 0;
+}
+
 typedef int (*option_parser_t)(struct comp_test_data *test_data,
 		const char *arg);
 
@@ -544,8 +555,10 @@ static struct option lgopts[] = {
 	{ CPERF_HUFFMAN_ENC, required_argument, 0, 0 },
 	{ CPERF_LEVEL, required_argument, 0, 0 },
 	{ CPERF_WINDOW_SIZE, required_argument, 0, 0 },
+	{ CPERF_EXTERNAL_MBUFS, 0, 0, 0 },
 	{ NULL, 0, 0, 0 }
 };
+
 static int
 comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data)
 {
@@ -563,6 +576,7 @@ comp_perf_opts_parse_long(int opt_idx, struct comp_test_data *test_data)
 		{ CPERF_HUFFMAN_ENC,	parse_huffman_enc },
 		{ CPERF_LEVEL,		parse_level },
 		{ CPERF_WINDOW_SIZE,	parse_window_sz },
+		{ CPERF_EXTERNAL_MBUFS,	parse_external_mbufs },
 	};
 	unsigned int i;
 
@@ -618,6 +632,7 @@ comp_perf_options_default(struct comp_test_data *test_data)
 	test_data->level_lst.max = RTE_COMP_LEVEL_MAX;
 	test_data->level_lst.inc = 1;
 	test_data->test = CPERF_TEST_TYPE_BENCHMARK;
+	test_data->use_external_mbufs = 0;
 }
 
 int
diff --git a/app/test-compress-perf/comp_perf_test_benchmark.c b/app/test-compress-perf/comp_perf_test_benchmark.c
index 887459449..0c6bb9b45 100644
--- a/app/test-compress-perf/comp_perf_test_benchmark.c
+++ b/app/test-compress-perf/comp_perf_test_benchmark.c
@@ -15,7 +15,8 @@ cperf_benchmark_test_destructor(void *arg)
 {
 	if (arg) {
 		comp_perf_free_memory(
-				&((struct cperf_benchmark_ctx *)arg)->ver.mem);
+			((struct cperf_benchmark_ctx *)arg)->ver.options,
+			&((struct cperf_benchmark_ctx *)arg)->ver.mem);
 		rte_free(arg);
 	}
 }
diff --git a/app/test-compress-perf/comp_perf_test_common.c b/app/test-compress-perf/comp_perf_test_common.c
index 7b26734c9..1b8985b43 100644
--- a/app/test-compress-perf/comp_perf_test_common.c
+++ b/app/test-compress-perf/comp_perf_test_common.c
@@ -77,7 +77,8 @@ find_buf_size(uint32_t input_size)
 }
 
 void
-comp_perf_free_memory(struct cperf_mem_resources *mem)
+comp_perf_free_memory(struct comp_test_data *test_data,
+		      struct cperf_mem_resources *mem)
 {
 	uint32_t i;
 
@@ -96,26 +97,162 @@ comp_perf_free_memory(struct cperf_mem_resources *mem)
 	rte_mempool_free(mem->op_pool);
 	rte_mempool_free(mem->decomp_buf_pool);
 	rte_mempool_free(mem->comp_buf_pool);
+
+	/* external mbuf support */
+	if (mem->decomp_memzones != NULL) {
+		for (i = 0; i < test_data->total_segs; i++)
+			rte_memzone_free(mem->decomp_memzones[i]);
+		rte_free(mem->decomp_memzones);
+	}
+	if (mem->comp_memzones != NULL) {
+		for (i = 0; i < test_data->total_segs; i++)
+			rte_memzone_free(mem->comp_memzones[i]);
+		rte_free(mem->comp_memzones);
+	}
+	rte_free(mem->decomp_buf_infos);
+	rte_free(mem->comp_buf_infos);
+}
+
+static void
+comp_perf_extbuf_free_cb(void *addr __rte_unused, void *opaque __rte_unused)
+{
+}
+
+static const struct rte_memzone *
+comp_perf_make_memzone(const char *name, struct cperf_mem_resources *mem,
+		       unsigned int number, size_t size)
+{
+	unsigned int socket_id = rte_socket_id();
+	char mz_name[RTE_MEMZONE_NAMESIZE];
+	const struct rte_memzone *memzone;
+
+	snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "%s_s%u_d%u_q%u_%d", name,
+		 socket_id, mem->dev_id, mem->qp_id, number);
+	memzone = rte_memzone_lookup(mz_name);
+	if (memzone != NULL && memzone->len != size) {
+		rte_memzone_free(memzone);
+		memzone = NULL;
+	}
+	if (memzone == NULL) {
+		memzone = rte_memzone_reserve_aligned(mz_name, size, socket_id,
+				RTE_MEMZONE_IOVA_CONTIG, RTE_CACHE_LINE_SIZE);
+		if (memzone == NULL)
+			RTE_LOG(ERR, USER1, "Can't allocate memory zone %s\n",
+				mz_name);
+	}
+	return memzone;
+}
+
+static int
+comp_perf_allocate_external_mbufs(struct comp_test_data *test_data,
+				  struct cperf_mem_resources *mem)
+{
+	uint32_t i;
+
+	mem->comp_memzones = rte_zmalloc_socket(NULL,
+		test_data->total_segs * sizeof(struct rte_memzone *),
+		0, rte_socket_id());
+
+	if (mem->comp_memzones == NULL) {
+		RTE_LOG(ERR, USER1,
+			"Memory to hold the compression memzones could not be allocated\n");
+		return -1;
+	}
+
+	mem->decomp_memzones = rte_zmalloc_socket(NULL,
+		test_data->total_segs * sizeof(struct rte_memzone *),
+		0, rte_socket_id());
+
+	if (mem->decomp_memzones == NULL) {
+		RTE_LOG(ERR, USER1,
+			"Memory to hold the decompression memzones could not be allocated\n");
+		return -1;
+	}
+
+	mem->comp_buf_infos = rte_zmalloc_socket(NULL,
+		test_data->total_segs * sizeof(struct rte_mbuf_ext_shared_info),
+		0, rte_socket_id());
+
+	if (mem->comp_buf_infos == NULL) {
+		RTE_LOG(ERR, USER1,
+			"Memory to hold the compression buf infos could not be allocated\n");
+		return -1;
+	}
+
+	mem->decomp_buf_infos = rte_zmalloc_socket(NULL,
+		test_data->total_segs * sizeof(struct rte_mbuf_ext_shared_info),
+		0, rte_socket_id());
+
+	if (mem->decomp_buf_infos == NULL) {
+		RTE_LOG(ERR, USER1,
+			"Memory to hold the decompression buf infos could not be allocated\n");
+		return -1;
+	}
+
+	for (i = 0; i < test_data->total_segs; i++) {
+		mem->comp_memzones[i] = comp_perf_make_memzone("comp", mem,
+				i, test_data->out_seg_sz);
+		if (mem->comp_memzones[i] == NULL) {
+			RTE_LOG(ERR, USER1,
+				"Memory to hold the compression memzone could not be allocated\n");
+			return -1;
+		}
+
+		mem->decomp_memzones[i] = comp_perf_make_memzone("decomp", mem,
+				i, test_data->seg_sz);
+		if (mem->decomp_memzones[i] == NULL) {
+			RTE_LOG(ERR, USER1,
+				"Memory to hold the decompression memzone could not be allocated\n");
+			return -1;
+		}
+
+		mem->comp_buf_infos[i].free_cb =
+				comp_perf_extbuf_free_cb;
+		mem->comp_buf_infos[i].fcb_opaque = NULL;
+		rte_mbuf_ext_refcnt_set(&mem->comp_buf_infos[i], 1);
+
+		mem->decomp_buf_infos[i].free_cb =
+				comp_perf_extbuf_free_cb;
+		mem->decomp_buf_infos[i].fcb_opaque = NULL;
+		rte_mbuf_ext_refcnt_set(&mem->decomp_buf_infos[i], 1);
+	}
+
+	return 0;
 }
 
 int
 comp_perf_allocate_memory(struct comp_test_data *test_data,
 			  struct cperf_mem_resources *mem)
 {
+	uint16_t comp_mbuf_size;
+	uint16_t decomp_mbuf_size;
+
 	test_data->out_seg_sz = find_buf_size(test_data->seg_sz);
+
 	/* Number of segments for input and output
 	 * (compression and decompression)
 	 */
-	uint32_t total_segs = DIV_CEIL(test_data->input_data_sz,
+	test_data->total_segs = DIV_CEIL(test_data->input_data_sz,
 			test_data->seg_sz);
+
+	if (test_data->use_external_mbufs != 0) {
+		if (comp_perf_allocate_external_mbufs(test_data, mem) < 0)
+			return -1;
+		comp_mbuf_size = 0;
+		decomp_mbuf_size = 0;
+	} else {
+		comp_mbuf_size = test_data->out_seg_sz + RTE_PKTMBUF_HEADROOM;
+		decomp_mbuf_size = test_data->seg_sz + RTE_PKTMBUF_HEADROOM;
+	}
+
 	char pool_name[32] = "";
 
 	snprintf(pool_name, sizeof(pool_name), "comp_buf_pool_%u_qp_%u",
 			mem->dev_id, mem->qp_id);
 	mem->comp_buf_pool = rte_pktmbuf_pool_create(pool_name,
-				total_segs,
+				test_data->total_segs,
 				0, 0,
-				test_data->out_seg_sz + RTE_PKTMBUF_HEADROOM,
+				comp_mbuf_size,
 				rte_socket_id());
 	if (mem->comp_buf_pool == NULL) {
 		RTE_LOG(ERR, USER1, "Mbuf mempool could not be created\n");
@@ -125,15 +262,17 @@ comp_perf_allocate_memory(struct comp_test_data *test_data,
 	snprintf(pool_name, sizeof(pool_name), "decomp_buf_pool_%u_qp_%u",
 			mem->dev_id, mem->qp_id);
 	mem->decomp_buf_pool = rte_pktmbuf_pool_create(pool_name,
-				total_segs,
-				0, 0, test_data->seg_sz + RTE_PKTMBUF_HEADROOM,
+				test_data->total_segs,
+				0, 0,
+				decomp_mbuf_size,
 				rte_socket_id());
 	if (mem->decomp_buf_pool == NULL) {
 		RTE_LOG(ERR, USER1, "Mbuf mempool could not be created\n");
 		return -1;
 	}
 
-	mem->total_bufs = DIV_CEIL(total_segs, test_data->max_sgl_segs);
+	mem->total_bufs = DIV_CEIL(test_data->total_segs,
+				   test_data->max_sgl_segs);
 
 	snprintf(pool_name, sizeof(pool_name), "op_pool_%u_qp_%u",
 			mem->dev_id, mem->qp_id);
@@ -151,7 +290,8 @@ comp_perf_allocate_memory(struct comp_test_data *test_data,
 	 */
 	mem->compressed_data = rte_zmalloc_socket(NULL,
 				RTE_MAX(
-				    (size_t) test_data->out_seg_sz * total_segs,
+				    (size_t) test_data->out_seg_sz *
+							  test_data->total_segs,
 				    (size_t) MIN_COMPRESSED_BUF_SIZE),
 				0,
 				rte_socket_id());
@@ -188,7 +328,7 @@ comp_perf_allocate_memory(struct comp_test_data *test_data,
 		return -1;
 	}
 
-	buffer_info.total_segments = total_segs;
+	buffer_info.total_segments = test_data->total_segs;
 	buffer_info.segment_sz = test_data->seg_sz;
 	buffer_info.total_buffs = mem->total_bufs;
 	buffer_info.segments_per_buff = test_data->max_sgl_segs;
@@ -206,6 +346,8 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
 	uint8_t *data_addr;
 	uint32_t i, j;
 	uint16_t segs_per_mbuf = 0;
+	uint32_t cmz = 0;
+	uint32_t dmz = 0;
 
 	for (i = 0; i < mem->total_bufs; i++) {
 		/* Allocate data in input mbuf and copy data from input file */
@@ -217,6 +359,16 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
 		}
 
 		data_sz = RTE_MIN(remaining_data, test_data->seg_sz);
+
+		if (test_data->use_external_mbufs != 0) {
+			rte_pktmbuf_attach_extbuf(mem->decomp_bufs[i],
+					mem->decomp_memzones[dmz]->addr,
+					mem->decomp_memzones[dmz]->iova,
+					test_data->seg_sz,
+					&mem->decomp_buf_infos[dmz]);
+			dmz++;
+		}
+
 		data_addr = (uint8_t *) rte_pktmbuf_append(
 					mem->decomp_bufs[i], data_sz);
 		if (data_addr == NULL) {
@@ -244,6 +396,17 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
 			}
 
 			data_sz = RTE_MIN(remaining_data, test_data->seg_sz);
+
+			if (test_data->use_external_mbufs != 0) {
+				rte_pktmbuf_attach_extbuf(
+					next_seg,
+					mem->decomp_memzones[dmz]->addr,
+					mem->decomp_memzones[dmz]->iova,
+					test_data->seg_sz,
+					&mem->decomp_buf_infos[dmz]);
+				dmz++;
+			}
+
 			data_addr = (uint8_t *)rte_pktmbuf_append(next_seg,
 				data_sz);
 
@@ -271,6 +434,16 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
 			RTE_LOG(ERR, USER1, "Could not allocate mbuf\n");
 			return -1;
 		}
+
+		if (test_data->use_external_mbufs != 0) {
+			rte_pktmbuf_attach_extbuf(mem->comp_bufs[i],
+					mem->comp_memzones[cmz]->addr,
+					mem->comp_memzones[cmz]->iova,
+					test_data->out_seg_sz,
+					&mem->comp_buf_infos[cmz]);
+			cmz++;
+		}
+
 		data_addr = (uint8_t *) rte_pktmbuf_append(
 					mem->comp_bufs[i],
 					test_data->out_seg_sz);
@@ -290,6 +463,16 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
 				return -1;
 			}
 
+			if (test_data->use_external_mbufs != 0) {
+				rte_pktmbuf_attach_extbuf(
+					next_seg,
+					mem->comp_memzones[cmz]->addr,
+					mem->comp_memzones[cmz]->iova,
+					test_data->out_seg_sz,
+					&mem->comp_buf_infos[cmz]);
+				cmz++;
+			}
+
 			data_addr = (uint8_t *)rte_pktmbuf_append(next_seg,
 				test_data->out_seg_sz);
 			if (data_addr == NULL) {
diff --git a/app/test-compress-perf/comp_perf_test_common.h b/app/test-compress-perf/comp_perf_test_common.h
index c9e0c9081..920642888 100644
--- a/app/test-compress-perf/comp_perf_test_common.h
+++ b/app/test-compress-perf/comp_perf_test_common.h
@@ -26,13 +26,20 @@ struct cperf_mem_resources {
 	struct rte_mempool *comp_buf_pool;
 	struct rte_mempool *decomp_buf_pool;
 	struct rte_mempool *op_pool;
+
+	/* external mbuf support */
+	const struct rte_memzone **comp_memzones;
+	const struct rte_memzone **decomp_memzones;
+	struct rte_mbuf_ext_shared_info *comp_buf_infos;
+	struct rte_mbuf_ext_shared_info *decomp_buf_infos;
 };
 
 int
 param_range_check(uint16_t size, const struct rte_param_log2_range *range);
 
 void
-comp_perf_free_memory(struct cperf_mem_resources *mem);
+comp_perf_free_memory(struct comp_test_data *test_data,
+		      struct cperf_mem_resources *mem);
 
 int
 comp_perf_allocate_memory(struct comp_test_data *test_data,
diff --git a/app/test-compress-perf/comp_perf_test_verify.c b/app/test-compress-perf/comp_perf_test_verify.c
index f66f95ff7..758a22ff5 100644
--- a/app/test-compress-perf/comp_perf_test_verify.c
+++ b/app/test-compress-perf/comp_perf_test_verify.c
@@ -14,7 +14,9 @@ void
 cperf_verify_test_destructor(void *arg)
 {
 	if (arg) {
-		comp_perf_free_memory(&((struct cperf_verify_ctx *)arg)->mem);
+		comp_perf_free_memory(
+				((struct cperf_verify_ctx *)arg)->options,
+				&((struct cperf_verify_ctx *)arg)->mem);
 		rte_free(arg);
 	}
 }
-- 
2.17.1

Re: [dpdk-dev] [PATCH v2 0/2] Add external mbufs option

[Trahe, Fiona]

> -----Original Message-----
> From: Dybkowski, AdamX
> Sent: Tuesday, September 24, 2019 3:11 PM
> To: dev@dpdk.org; Trahe, Fiona <fiona.trahe@intel.com>; Trybula, ArturX
> <arturx.trybula@intel.com>; akhil.goyal@nxp.com
> Cc: Dybkowski, AdamX <adamx.dybkowski@intel.com>
> Subject: [PATCH v2 0/2] Add external mbufs option
> 
> This patchset adds a unit test of the external buffers
> functionality and a new option to the compression
> performance benchmark tool to use memzones as external
> buffers instead of the data put directly inside mbufs.
> ---
> v2:
> * Rebasing over the stateful decompression patch
> 
> This patch depends on https://patches.dpdk.org/cover/59610/
> 
> Adam Dybkowski (2):
>   test/compress: add external buffer in mbuf API test
>   app/compress-perf: add external mbufs option
> 
>  app/test-compress-perf/comp_perf_options.h    |   2 +
>  .../comp_perf_options_parse.c                 |  15 +
>  .../comp_perf_test_benchmark.c                |   3 +-
>  .../comp_perf_test_common.c                   | 201 ++++++++++-
>  .../comp_perf_test_common.h                   |   9 +-
>  .../comp_perf_test_verify.c                   |   4 +-
>  app/test/test_compressdev.c                   | 314 ++++++++++++------
>  7 files changed, 443 insertions(+), 105 deletions(-)
> 
> --
> 2.17.1
Series
Acked-by: Fiona Trahe <fiona.trahe@intel.com>

Re: [dpdk-dev] [PATCH v2 0/2] Add external mbufs option

[Akhil Goyal]

> > Adam Dybkowski (2):
> >   test/compress: add external buffer in mbuf API test
> >   app/compress-perf: add external mbufs option
> >
> >  app/test-compress-perf/comp_perf_options.h    |   2 +
> >  .../comp_perf_options_parse.c                 |  15 +
> >  .../comp_perf_test_benchmark.c                |   3 +-
> >  .../comp_perf_test_common.c                   | 201 ++++++++++-
> >  .../comp_perf_test_common.h                   |   9 +-
> >  .../comp_perf_test_verify.c                   |   4 +-
> >  app/test/test_compressdev.c                   | 314 ++++++++++++------
> >  7 files changed, 443 insertions(+), 105 deletions(-)
> >
> > --
> > 2.17.1
> Series
> Acked-by: Fiona Trahe <fiona.trahe@intel.com>
Applied to dpdk-next-crypto

Thanks.