DPDK patches and discussions
 help / color / mirror / Atom feed
* [dpdk-dev] [PATCH 1/2] pipeline: modularize the instruction optimizer
@ 2021-04-11 23:23 Cristian Dumitrescu
  2021-04-11 23:23 ` [dpdk-dev] [PATCH 2/2] pipeline: autodetect endianness of action args Cristian Dumitrescu
  0 siblings, 1 reply; 15+ messages in thread
From: Cristian Dumitrescu @ 2021-04-11 23:23 UTC (permalink / raw)
  To: dev

Decouple between the different instruction optimizer. Allow each
optimization to run as a separate iteration on the entire instruction
stream.

Signed-off-by: Cristian Dumitrescu <cristian.dumitrescu@intel.com>
---
 lib/librte_pipeline/rte_swx_pipeline.c | 196 ++++++++++++++++++-------
 1 file changed, 142 insertions(+), 54 deletions(-)

diff --git a/lib/librte_pipeline/rte_swx_pipeline.c b/lib/librte_pipeline/rte_swx_pipeline.c
index dc2a155ed..ba828cbda 100644
--- a/lib/librte_pipeline/rte_swx_pipeline.c
+++ b/lib/librte_pipeline/rte_swx_pipeline.c
@@ -8085,8 +8085,34 @@ instr_verify(struct rte_swx_pipeline *p __rte_unused,
 	return 0;
 }
 
+static uint32_t
+instr_compact(struct instruction *instructions,
+	      struct instruction_data *instruction_data,
+	      uint32_t n_instructions)
+{
+	uint32_t i, pos = 0;
+
+	/* Eliminate the invalid instructions that have been optimized out. */
+	for (i = 0; i < n_instructions; i++) {
+		struct instruction *instr = &instructions[i];
+		struct instruction_data *data = &instruction_data[i];
+
+		if (data->invalid)
+			continue;
+
+		if (i != pos) {
+			memcpy(&instructions[pos], instr, sizeof(*instr));
+			memcpy(&instruction_data[pos], data, sizeof(*data));
+		}
+
+		pos++;
+	}
+
+	return pos;
+}
+
 static int
-instr_pattern_extract_many_detect(struct instruction *instr,
+instr_pattern_extract_many_search(struct instruction *instr,
 				  struct instruction_data *data,
 				  uint32_t n_instr,
 				  uint32_t *n_pattern_instr)
@@ -8115,9 +8141,9 @@ instr_pattern_extract_many_detect(struct instruction *instr,
 }
 
 static void
-instr_pattern_extract_many_optimize(struct instruction *instr,
-				    struct instruction_data *data,
-				    uint32_t n_instr)
+instr_pattern_extract_many_replace(struct instruction *instr,
+				   struct instruction_data *data,
+				   uint32_t n_instr)
 {
 	uint32_t i;
 
@@ -8131,8 +8157,46 @@ instr_pattern_extract_many_optimize(struct instruction *instr,
 	}
 }
 
+static uint32_t
+instr_pattern_extract_many_optimize(struct instruction *instructions,
+				    struct instruction_data *instruction_data,
+				    uint32_t n_instructions)
+{
+	uint32_t i;
+
+	for (i = 0; i < n_instructions; ) {
+		struct instruction *instr = &instructions[i];
+		struct instruction_data *data = &instruction_data[i];
+		uint32_t n_instr = 0;
+		int detected;
+
+		/* Extract many. */
+		detected = instr_pattern_extract_many_search(instr,
+							     data,
+							     n_instructions - i,
+							     &n_instr);
+		if (detected) {
+			instr_pattern_extract_many_replace(instr,
+							   data,
+							   n_instr);
+			i += n_instr;
+			continue;
+		}
+
+		/* No pattern starting at the current instruction. */
+		i++;
+	}
+
+	/* Eliminate the invalid instructions that have been optimized out. */
+	n_instructions = instr_compact(instructions,
+				       instruction_data,
+				       n_instructions);
+
+	return n_instructions;
+}
+
 static int
-instr_pattern_emit_many_tx_detect(struct instruction *instr,
+instr_pattern_emit_many_tx_search(struct instruction *instr,
 				  struct instruction_data *data,
 				  uint32_t n_instr,
 				  uint32_t *n_pattern_instr)
@@ -8169,9 +8233,9 @@ instr_pattern_emit_many_tx_detect(struct instruction *instr,
 }
 
 static void
-instr_pattern_emit_many_tx_optimize(struct instruction *instr,
-				    struct instruction_data *data,
-				    uint32_t n_instr)
+instr_pattern_emit_many_tx_replace(struct instruction *instr,
+				   struct instruction_data *data,
+				   uint32_t n_instr)
 {
 	uint32_t i;
 
@@ -8192,8 +8256,46 @@ instr_pattern_emit_many_tx_optimize(struct instruction *instr,
 	data[i].invalid = 1;
 }
 
+static uint32_t
+instr_pattern_emit_many_tx_optimize(struct instruction *instructions,
+				    struct instruction_data *instruction_data,
+				    uint32_t n_instructions)
+{
+	uint32_t i;
+
+	for (i = 0; i < n_instructions; ) {
+		struct instruction *instr = &instructions[i];
+		struct instruction_data *data = &instruction_data[i];
+		uint32_t n_instr = 0;
+		int detected;
+
+		/* Emit many + TX. */
+		detected = instr_pattern_emit_many_tx_search(instr,
+							     data,
+							     n_instructions - i,
+							     &n_instr);
+		if (detected) {
+			instr_pattern_emit_many_tx_replace(instr,
+							   data,
+							   n_instr);
+			i += n_instr;
+			continue;
+		}
+
+		/* No pattern starting at the current instruction. */
+		i++;
+	}
+
+	/* Eliminate the invalid instructions that have been optimized out. */
+	n_instructions = instr_compact(instructions,
+				       instruction_data,
+				       n_instructions);
+
+	return n_instructions;
+}
+
 static int
-instr_pattern_dma_many_detect(struct instruction *instr,
+instr_pattern_dma_many_search(struct instruction *instr,
 			      struct instruction_data *data,
 			      uint32_t n_instr,
 			      uint32_t *n_pattern_instr)
@@ -8222,9 +8324,9 @@ instr_pattern_dma_many_detect(struct instruction *instr,
 }
 
 static void
-instr_pattern_dma_many_optimize(struct instruction *instr,
-				struct instruction_data *data,
-				uint32_t n_instr)
+instr_pattern_dma_many_replace(struct instruction *instr,
+			       struct instruction_data *data,
+			       uint32_t n_instr)
 {
 	uint32_t i;
 
@@ -8240,11 +8342,11 @@ instr_pattern_dma_many_optimize(struct instruction *instr,
 }
 
 static uint32_t
-instr_optimize(struct instruction *instructions,
+instr_pattern_dma_many_optimize(struct instruction *instructions,
 	       struct instruction_data *instruction_data,
 	       uint32_t n_instructions)
 {
-	uint32_t i, pos = 0;
+	uint32_t i;
 
 	for (i = 0; i < n_instructions; ) {
 		struct instruction *instr = &instructions[i];
@@ -8252,39 +8354,13 @@ instr_optimize(struct instruction *instructions,
 		uint32_t n_instr = 0;
 		int detected;
 
-		/* Extract many. */
-		detected = instr_pattern_extract_many_detect(instr,
-							     data,
-							     n_instructions - i,
-							     &n_instr);
-		if (detected) {
-			instr_pattern_extract_many_optimize(instr,
-							    data,
-							    n_instr);
-			i += n_instr;
-			continue;
-		}
-
-		/* Emit many + TX. */
-		detected = instr_pattern_emit_many_tx_detect(instr,
-							     data,
-							     n_instructions - i,
-							     &n_instr);
-		if (detected) {
-			instr_pattern_emit_many_tx_optimize(instr,
-							    data,
-							    n_instr);
-			i += n_instr;
-			continue;
-		}
-
 		/* DMA many. */
-		detected = instr_pattern_dma_many_detect(instr,
+		detected = instr_pattern_dma_many_search(instr,
 							 data,
 							 n_instructions - i,
 							 &n_instr);
 		if (detected) {
-			instr_pattern_dma_many_optimize(instr, data, n_instr);
+			instr_pattern_dma_many_replace(instr, data, n_instr);
 			i += n_instr;
 			continue;
 		}
@@ -8294,22 +8370,34 @@ instr_optimize(struct instruction *instructions,
 	}
 
 	/* Eliminate the invalid instructions that have been optimized out. */
-	for (i = 0; i < n_instructions; i++) {
-		struct instruction *instr = &instructions[i];
-		struct instruction_data *data = &instruction_data[i];
+	n_instructions = instr_compact(instructions,
+				       instruction_data,
+				       n_instructions);
 
-		if (data->invalid)
-			continue;
+	return n_instructions;
+}
 
-		if (i != pos) {
-			memcpy(&instructions[pos], instr, sizeof(*instr));
-			memcpy(&instruction_data[pos], data, sizeof(*data));
-		}
+static uint32_t
+instr_optimize(struct instruction *instructions,
+	       struct instruction_data *instruction_data,
+	       uint32_t n_instructions)
+{
+	/* Extract many. */
+	n_instructions = instr_pattern_extract_many_optimize(instructions,
+							     instruction_data,
+							     n_instructions);
 
-		pos++;
-	}
+	/* Emit many + TX. */
+	n_instructions = instr_pattern_emit_many_tx_optimize(instructions,
+							     instruction_data,
+							     n_instructions);
 
-	return pos;
+	/* DMA many. */
+	n_instructions = instr_pattern_dma_many_optimize(instructions,
+							 instruction_data,
+							 n_instructions);
+
+	return n_instructions;
 }
 
 static int
-- 
2.17.1


^ permalink raw reply	[flat|nested] 15+ messages in thread

end of thread, other threads:[~2021-04-21 15:12 UTC | newest]

Thread overview: 15+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-04-11 23:23 [dpdk-dev] [PATCH 1/2] pipeline: modularize the instruction optimizer Cristian Dumitrescu
2021-04-11 23:23 ` [dpdk-dev] [PATCH 2/2] pipeline: autodetect endianness of action args Cristian Dumitrescu
2021-04-20  0:48   ` Thomas Monjalon
2021-04-20 10:04     ` Dumitrescu, Cristian
2021-04-20 10:06       ` Thomas Monjalon
2021-04-20 10:20         ` Dumitrescu, Cristian
2021-04-20 14:48           ` Aaron Conole
2021-04-20 19:57   ` Thomas Monjalon
2021-04-21  7:49     ` Ali Alnubani
2021-04-21 12:57       ` Aaron Conole
2021-04-21 13:03         ` Ali Alnubani
2021-04-21 13:21           ` Aaron Conole
2021-04-21 13:58       ` Dumitrescu, Cristian
2021-04-21 14:24         ` Ali Alnubani
2021-04-21 15:10           ` Dumitrescu, Cristian

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).