DPDK patches and discussions
 help / color / mirror / Atom feed
From: Georgios Katsikas <katsikas.gp@gmail.com>
To: wisamm@mellanox.com
Cc: dev@dpdk.org, Georgios Katsikas <katsikas.gp@gmail.com>
Subject: [dpdk-dev] [PATCH] app/flow-perf: configurable rule batches
Date: Thu, 24 Sep 2020 11:10:53 +0200
Message-ID: <20200924091053.8373-1-katsikas.gp@gmail.com> (raw)

* One can now configure the number of rules per batch
* Refactored flow_count variable to rules_count as it is
related to the newly added rules_batch variable
* Added default values to usage function

Signed-off-by: Georgios Katsikas <katsikas.gp@gmail.com>
---
 app/test-flow-perf/main.c | 87 +++++++++++++++++++++++----------------
 1 file changed, 51 insertions(+), 36 deletions(-)

diff --git a/app/test-flow-perf/main.c b/app/test-flow-perf/main.c
index c420da6a5..904feb80f 100644
--- a/app/test-flow-perf/main.c
+++ b/app/test-flow-perf/main.c
@@ -40,7 +40,8 @@
 
 #define MAX_ITERATIONS             100
 #define DEFAULT_RULES_COUNT    4000000
-#define DEFAULT_ITERATION       100000
+#define DEFAULT_RULES_BATCH     100000
+#define DEFAULT_GROUP                0
 
 struct rte_flow *flow;
 static uint8_t flow_group;
@@ -62,8 +63,8 @@ static bool enable_fwd;
 
 static struct rte_mempool *mbuf_mp;
 static uint32_t nb_lcores;
-static uint32_t flows_count;
-static uint32_t iterations_number;
+static uint32_t rules_count;
+static uint32_t rules_batch;
 static uint32_t hairpin_queues_num; /* total hairpin q number - default: 0 */
 static uint32_t nb_lcores;
 
@@ -98,8 +99,8 @@ usage(char *progname)
 {
 	printf("\nusage: %s\n", progname);
 	printf("\nControl configurations:\n");
-	printf("  --flows-count=N: to set the number of needed"
-		" flows to insert, default is 4,000,000\n");
+	printf("  --rules-count=N: to set the number of needed"
+		" rules to insert, default is %d\n", DEFAULT_RULES_COUNT);
 	printf("  --dump-iterations: To print rates for each"
 		" iteration\n");
 	printf("  --deletion-rate: Enable deletion rate"
@@ -108,13 +109,15 @@ usage(char *progname)
 	printf("  --enable-fwd: To enable packets forwarding"
 		" after insertion\n");
 	printf("  --portmask=N: hexadecimal bitmask of ports used\n");
+	printf("  --rules-batch=N: set number of batched rules,"
+		" default is %d\n", DEFAULT_RULES_BATCH);
 
 	printf("To set flow attributes:\n");
 	printf("  --ingress: set ingress attribute in flows\n");
 	printf("  --egress: set egress attribute in flows\n");
 	printf("  --transfer: set transfer attribute in flows\n");
 	printf("  --group=N: set group for all flows,"
-		" default is 0\n");
+		" default is %d\n", DEFAULT_GROUP);
 
 	printf("To set flow items:\n");
 	printf("  --ether: add ether layer in flow items\n");
@@ -527,7 +530,8 @@ args_parse(int argc, char **argv)
 	static const struct option lgopts[] = {
 		/* Control */
 		{ "help",                       0, 0, 0 },
-		{ "flows-count",                1, 0, 0 },
+		{ "rules-count",                1, 0, 0 },
+		{ "rules-batch",                1, 0, 0 },
 		{ "dump-iterations",            0, 0, 0 },
 		{ "deletion-rate",              0, 0, 0 },
 		{ "dump-socket-mem",            0, 0, 0 },
@@ -705,13 +709,24 @@ args_parse(int argc, char **argv)
 			}
 			/* Control */
 			if (strcmp(lgopts[opt_idx].name,
-					"flows-count") == 0) {
+					"rules-batch") == 0) {
 				n = atoi(optarg);
-				if (n > (int) iterations_number)
-					flows_count = n;
+				if (n >= DEFAULT_RULES_BATCH)
+					rules_batch = n;
 				else {
-					printf("\n\nflows_count should be > %d\n",
-						iterations_number);
+					printf("\n\nrules_batch should be >= %d\n",
+						DEFAULT_RULES_BATCH);
+					rte_exit(EXIT_SUCCESS, " ");
+				}
+			}
+			if (strcmp(lgopts[opt_idx].name,
+					"rules-count") == 0) {
+				n = atoi(optarg);
+				if (n >= (int) rules_batch)
+					rules_count = n;
+				else {
+					printf("\n\nrules_count should be >= %d\n",
+						rules_batch);
 					rte_exit(EXIT_SUCCESS, " ");
 				}
 			}
@@ -826,13 +841,13 @@ destroy_flows(int port_id, struct rte_flow **flow_list)
 	for (i = 0; i < MAX_ITERATIONS; i++)
 		cpu_time_per_iter[i] = -1;
 
-	if (iterations_number > flows_count)
-		iterations_number = flows_count;
+	if (rules_batch > rules_count)
+		rules_batch = rules_count;
 
 	/* Deletion Rate */
 	printf("Flows Deletion on port = %d\n", port_id);
 	start_iter = clock();
-	for (i = 0; i < flows_count; i++) {
+	for (i = 0; i < rules_count; i++) {
 		if (flow_list[i] == 0)
 			break;
 
@@ -842,11 +857,11 @@ destroy_flows(int port_id, struct rte_flow **flow_list)
 			rte_exit(EXIT_FAILURE, "Error in deleting flow");
 		}
 
-		if (i && !((i + 1) % iterations_number)) {
+		if (i && !((i + 1) % rules_batch)) {
 			/* Save the deletion rate of each iter */
 			end_iter = clock();
 			delta = (double) (end_iter - start_iter);
-			iter_id = ((i + 1) / iterations_number) - 1;
+			iter_id = ((i + 1) / rules_batch) - 1;
 			cpu_time_per_iter[iter_id] =
 				delta / CLOCKS_PER_SEC;
 			cpu_time_used += cpu_time_per_iter[iter_id];
@@ -859,21 +874,21 @@ destroy_flows(int port_id, struct rte_flow **flow_list)
 		for (i = 0; i < MAX_ITERATIONS; i++) {
 			if (cpu_time_per_iter[i] == -1)
 				continue;
-			delta = (double)(iterations_number /
+			delta = (double)(rules_batch /
 				cpu_time_per_iter[i]);
 			flows_rate = delta / 1000;
 			printf(":: Iteration #%d: %d flows "
 				"in %f sec[ Rate = %f K/Sec ]\n",
-				i, iterations_number,
+				i, rules_batch,
 				cpu_time_per_iter[i], flows_rate);
 		}
 
 	/* Deletion rate for all flows */
-	flows_rate = ((double) (flows_count / cpu_time_used) / 1000);
+	flows_rate = ((double) (rules_count / cpu_time_used) / 1000);
 	printf("\n:: Total flow deletion rate -> %f K/Sec\n",
 		flows_rate);
 	printf(":: The time for deleting %d in flows %f seconds\n",
-		flows_count, cpu_time_used);
+		rules_count, cpu_time_used);
 }
 
 static inline void
@@ -902,13 +917,13 @@ flows_handler(void)
 	for (i = 0; i < MAX_ITERATIONS; i++)
 		cpu_time_per_iter[i] = -1;
 
-	if (iterations_number > flows_count)
-		iterations_number = flows_count;
+	if (rules_batch > rules_count)
+		rules_batch = rules_count;
 
-	printf(":: Flows Count per port: %d\n", flows_count);
+	printf(":: Flows Count per port: %d\n", rules_count);
 
 	flow_list = rte_zmalloc("flow_list",
-		(sizeof(struct rte_flow *) * flows_count) + 1, 0);
+		(sizeof(struct rte_flow *) * rules_count) + 1, 0);
 	if (flow_list == NULL)
 		rte_exit(EXIT_FAILURE, "No Memory available!");
 
@@ -941,7 +956,7 @@ flows_handler(void)
 		/* Insertion Rate */
 		printf("Flows insertion on port = %d\n", port_id);
 		start_iter = clock();
-		for (i = 0; i < flows_count; i++) {
+		for (i = 0; i < rules_count; i++) {
 			flow = generate_flow(port_id, flow_group,
 				flow_attrs, flow_items, flow_actions,
 				JUMP_ACTION_TABLE, i,
@@ -950,7 +965,7 @@ flows_handler(void)
 				&error);
 
 			if (force_quit)
-				i = flows_count;
+				i = rules_count;
 
 			if (!flow) {
 				print_flow_error(error);
@@ -959,11 +974,11 @@ flows_handler(void)
 
 			flow_list[flow_index++] = flow;
 
-			if (i && !((i + 1) % iterations_number)) {
+			if (i && !((i + 1) % rules_batch)) {
 				/* Save the insertion rate of each iter */
 				end_iter = clock();
 				delta = (double) (end_iter - start_iter);
-				iter_id = ((i + 1) / iterations_number) - 1;
+				iter_id = ((i + 1) / rules_batch) - 1;
 				cpu_time_per_iter[iter_id] =
 					delta / CLOCKS_PER_SEC;
 				cpu_time_used += cpu_time_per_iter[iter_id];
@@ -976,21 +991,21 @@ flows_handler(void)
 			for (i = 0; i < MAX_ITERATIONS; i++) {
 				if (cpu_time_per_iter[i] == -1)
 					continue;
-				delta = (double)(iterations_number /
+				delta = (double)(rules_batch /
 					cpu_time_per_iter[i]);
 				flows_rate = delta / 1000;
 				printf(":: Iteration #%d: %d flows "
 					"in %f sec[ Rate = %f K/Sec ]\n",
-					i, iterations_number,
+					i, rules_batch,
 					cpu_time_per_iter[i], flows_rate);
 			}
 
 		/* Insertion rate for all flows */
-		flows_rate = ((double) (flows_count / cpu_time_used) / 1000);
+		flows_rate = ((double) (rules_count / cpu_time_used) / 1000);
 		printf("\n:: Total flow insertion rate -> %f K/Sec\n",
 						flows_rate);
 		printf(":: The time for creating %d in flows %f seconds\n",
-						flows_count, cpu_time_used);
+						rules_count, cpu_time_used);
 
 		if (delete_flag)
 			destroy_flows(port_id, flow_list);
@@ -1415,11 +1430,11 @@ main(int argc, char **argv)
 
 	force_quit = false;
 	dump_iterations = false;
-	flows_count = DEFAULT_RULES_COUNT;
-	iterations_number = DEFAULT_ITERATION;
+	rules_count = DEFAULT_RULES_COUNT;
+	rules_batch = DEFAULT_RULES_BATCH;
 	delete_flag = false;
 	dump_socket_mem_flag = false;
-	flow_group = 0;
+	flow_group = DEFAULT_GROUP;
 
 	signal(SIGINT, signal_handler);
 	signal(SIGTERM, signal_handler);
-- 
2.17.1


             reply	other threads:[~2020-09-24  9:11 UTC|newest]

Thread overview: 11+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2020-09-24  9:10 Georgios Katsikas [this message]
2020-09-24 12:01 ` Wisam Monther
2020-10-05 17:16   ` Georgios Katsikas
2020-10-05 22:25     ` Thomas Monjalon
2020-10-11 10:33       ` Georgios Katsikas
2020-10-11 10:03 Georgios Katsikas
2020-11-03 11:26 ` Georgios Katsikas
2020-11-04  8:04   ` Wisam Monther
2020-11-04 11:11     ` Georgios Katsikas
2020-11-04 11:25       ` Wisam Monther
2020-11-04 20:46     ` Thomas Monjalon

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20200924091053.8373-1-katsikas.gp@gmail.com \
    --to=katsikas.gp@gmail.com \
    --cc=dev@dpdk.org \
    --cc=wisamm@mellanox.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

DPDK patches and discussions

This inbox may be cloned and mirrored by anyone:

	git clone --mirror https://inbox.dpdk.org/dev/0 dev/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 dev dev/ https://inbox.dpdk.org/dev \
		dev@dpdk.org
	public-inbox-index dev

Example config snippet for mirrors.
Newsgroup available over NNTP:
	nntp://inbox.dpdk.org/inbox.dpdk.dev


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git