X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=app%2Ftest-compress-perf%2Fcomp_perf_test_common.c;h=b402a0d839661171a6975b855f0cf5f8bbec6fbc;hb=c17af95a19e30c8d89eb96ceca99f60474ca2ac4;hp=7b26734c9bfad62ad9aebf39fea8380254404cf2;hpb=c591df32ad8e9beb59c5970a893c20b7574c4c87;p=dpdk.git

diff --git a/app/test-compress-perf/comp_perf_test_common.c b/app/test-compress-perf/comp_perf_test_common.c
index 7b26734c9b..b402a0d839 100644
--- a/app/test-compress-perf/comp_perf_test_common.c
+++ b/app/test-compress-perf/comp_perf_test_common.c
@@ -9,7 +9,8 @@
 
 #include "comp_perf.h"
 #include "comp_perf_options.h"
-#include "comp_perf_test_benchmark.h"
+#include "comp_perf_test_throughput.h"
+#include "comp_perf_test_cyclecount.h"
 #include "comp_perf_test_common.h"
 #include "comp_perf_test_verify.h"
 
@@ -77,7 +78,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 +98,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,21 +263,25 @@ 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);
+
+	/* one mempool for both src and dst mbufs */
 	mem->op_pool = rte_comp_op_pool_create(pool_name,
-				  mem->total_bufs,
-				  0, 0, rte_socket_id());
+				mem->total_bufs * 2,
+				0, 0, rte_socket_id());
 	if (mem->op_pool == NULL) {
 		RTE_LOG(ERR, USER1, "Comp op mempool could not be created\n");
 		return -1;
@@ -151,7 +293,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 +331,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 +349,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 +362,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 +399,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 +437,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 +466,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) {
@@ -312,20 +498,24 @@ prepare_bufs(struct comp_test_data *test_data, struct cperf_mem_resources *mem)
 }
 
 void
-print_test_dynamics(void)
+print_test_dynamics(const struct comp_test_data *test_data)
 {
 	uint32_t opt_total_segs = DIV_CEIL(buffer_info.input_data_sz,
 			MAX_SEG_SIZE);
 
 	if (buffer_info.total_buffs > 1) {
-		printf("\nWarning: for the current input parameters, number"
+		if (test_data->test == CPERF_TEST_TYPE_THROUGHPUT) {
+			printf("\nWarning: for the current input parameters, number"
 				" of ops is higher than one, which may result"
 				" in sub-optimal performance.\n");
-		printf("To improve the performance (for the current"
+			printf("To improve the performance (for the current"
 				" input data) following parameters are"
 				" suggested:\n");
-		printf("	* Segment size: %d\n", MAX_SEG_SIZE);
-		printf("	* Number of segments: %u\n", opt_total_segs);
+			printf("	* Segment size: %d\n",
+			       MAX_SEG_SIZE);
+			printf("	* Number of segments: %u\n",
+			       opt_total_segs);
+		}
 	} else if (buffer_info.total_buffs == 1) {
 		printf("\nInfo: there is only one op with %u segments -"
 				" the compression ratio is the best.\n",