diff mbox series

[1/2] pipeline: modularize the instruction optimizer

Message ID 20210411232338.4005-1-cristian.dumitrescu@intel.com (mailing list archive)
State Accepted
Delegated to: Thomas Monjalon
Headers show
Series [1/2] pipeline: modularize the instruction optimizer | expand

Checks

Context Check Description
ci/Performance-Testing fail build patch failure
ci/checkpatch success coding style OK

Commit Message

Dumitrescu, Cristian April 11, 2021, 11:23 p.m. UTC
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 mbox series

Patch

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