Remove impactless optimizations

Author: 3tty0n

rpython/jit/codewriter/genextension.py

@@ -90,20 +90,17 @@ def generate(self):
                     self._make_code(self.pc_to_index[spec.orig_pc], spec.insn)
                 code_and_spec_per_pc[pc] = (str(py.code.Source("\n".join(self.code)).deindent()), spec)
 
-        # Analyze PC transitions for trace prediction and threaded code
-        pc_transitions = self._analyze_pc_transitions(code_and_spec_per_pc)
-
         self.code = []
         allconsts = set()
-        num_pcs = len(code_and_spec_per_pc)
-        use_dict_dispatch = num_pcs > DICT_DISPATCH_THRESHOLD
 
-        if use_dict_dispatch:
-            # Dictionary-based dispatch for large functions - O(1) lookup
-            self._generate_dict_dispatch(code_and_spec_per_pc, allconsts, pc_transitions)
-        else:
-            # Optimized if/elif dispatch with trace prediction for small functions
-            self._generate_threaded_dispatch(code_and_spec_per_pc, allconsts, pc_transitions)
+        # Generate simple if/elif dispatch
+        for pc, (code, spec) in sorted(code_and_spec_per_pc.iteritems()):
+            allconsts.update(spec.constant_registers)
+            self.code.append("if pc == %s: # %s %s" % (pc, spec.insn, spec.constant_registers))
+            self.code.append("    self.pc = %s" % (self.pc_to_nextpc[spec.orig_pc], ))
+            for line in str(py.code.Source(code).indent('    ')).splitlines():
+                self.code.append(line)
+        self.code.append("assert 0 # unreachable")
 
         allcode = []
         allconsts = sorted(["%s%s" % (val.kind[0], val.index) for val in allconsts])
@@ -139,121 +136,6 @@ def generate(self):
         self.jitcode.genext_function = d['jit_shortcut']
         self.jitcode.genext_function.__name__ += "_" + self.jitcode.name
 
-    def _analyze_pc_transitions(self, code_and_spec_per_pc):
-        """
-        Analyze PC transitions to find:
-        1. Linear chains (pc A always goes to pc B)
-        2. Most likely next PC for each block (for trace prediction)
-        Returns a dict mapping pc -> (likely_next_pc, is_unconditional)
-        """
-        transitions = {}
-        for pc, (code, spec) in code_and_spec_per_pc.iteritems():
-            if code is None:
-                continue
-            # Parse the code to find 'pc = X' assignments
-            next_pcs = []
-            lines = code.split('\n')
-            for line in lines:
-                line = line.strip()
-                if line.startswith('pc = ') and 'self.pc' not in line:
-                    try:
-                        next_pc = int(line.split('=')[1].strip())
-                        next_pcs.append(next_pc)
-                    except (ValueError, IndexError):
-                        pass
-            if len(next_pcs) == 1:
-                # Unconditional transition - perfect for threaded code
-                transitions[pc] = (next_pcs[0], True)
-            elif next_pcs:
-                # Multiple targets - use first as likely prediction
-                transitions[pc] = (next_pcs[0], False)
-        return transitions
-
-    def _generate_dict_dispatch(self, code_and_spec_per_pc, allconsts, pc_transitions):
-        """
-        Generate dictionary-based dispatch for O(1) PC lookup.
-        This is more efficient for functions with many PC values.
-
-        For large functions, we use a true dictionary-based dispatch where
-        each PC handler is a closure that updates pc and continues.
-        """
-        # Build the dispatch cases
-        dispatch_cases = []
-        for pc, (code, spec) in sorted(code_and_spec_per_pc.iteritems()):
-            allconsts.update(spec.constant_registers)
-            case_lines = []
-            case_lines.append("self.pc = %s" % (self.pc_to_nextpc[spec.orig_pc], ))
-            for line in str(py.code.Source(code).indent('')).splitlines():
-                case_lines.append(line)
-            dispatch_cases.append((pc, case_lines, spec))
-
-        # Generate the dispatch code - still use if/elif but with optimized ordering
-        # based on trace prediction (most likely targets first)
-        for pc, case_lines, spec in dispatch_cases:
-            self.code.append("if pc == %s: # %s %s" % (pc, spec.insn, spec.constant_registers))
-            for line in case_lines:
-                self.code.append("    " + line)
-
-        self.code.append("assert 0 # unreachable")
-
-    def _generate_threaded_dispatch(self, code_and_spec_per_pc, allconsts, pc_transitions):
-        """
-        Generate threaded code dispatch with trace prediction.
-        For blocks with unconditional transitions, inline the next block
-        to avoid dispatch overhead (direct threading).
-
-        This optimization:
-        1. Finds chains of blocks with unconditional transitions
-        2. Inlines successive blocks to avoid dispatch overhead
-        3. Preserves the original output format for compatibility
-        """
-        # For now, generate standard dispatch to preserve test compatibility
-        # The threaded optimization happens at a lower level via _try_inline_chain
-        for pc, (code, spec) in sorted(code_and_spec_per_pc.iteritems()):
-            allconsts.update(spec.constant_registers)
-            self.code.append("if pc == %s: # %s %s" % (pc, spec.insn, spec.constant_registers))
-            self.code.append("    self.pc = %s" % (self.pc_to_nextpc[spec.orig_pc], ))
-            for line in str(py.code.Source(code).indent('    ')).splitlines():
-                self.code.append(line)
-        self.code.append("assert 0 # unreachable")
-
-    def _find_threaded_chains(self, sorted_pcs, pc_transitions, code_and_spec_per_pc):
-        """
-        Find chains of PCs that can be threaded together (inlined).
-        A chain is a sequence of blocks where each unconditionally jumps to the next.
-        """
-        chains = {}
-        in_chain = set()
-
-        for start_pc in sorted_pcs:
-            if start_pc in in_chain:
-                continue
-
-            chain = [start_pc]
-            current_pc = start_pc
-
-            # Follow unconditional transitions
-            while current_pc in pc_transitions:
-                next_pc, is_unconditional = pc_transitions[current_pc]
-                if not is_unconditional:
-                    break
-                if next_pc in in_chain or next_pc == start_pc:
-                    break  # Avoid cycles and already-chained blocks
-                if next_pc not in code_and_spec_per_pc:
-                    break
-                chain.append(next_pc)
-                in_chain.add(next_pc)
-                current_pc = next_pc
-                # Limit chain length to prevent excessive inlining
-                if len(chain) >= MAX_INLINE_DEPTH:
-                    break
-
-            if len(chain) > 1:
-                chains[start_pc] = chain
-                in_chain.add(start_pc)
-
-        return chains
-
     def _make_code(self, index, insn):
         self._reset_insn()
         assert not (isinstance(insn[0], Label) or insn[0] == '---')
@@ -643,9 +525,6 @@ def next_possible_pcs(self, insn, needed_label, nextpc):
 # Maximum depth for inlining to prevent code explosion
 MAX_INLINE_DEPTH = 16
 
-# Threshold for switching to dictionary-based dispatch
-DICT_DISPATCH_THRESHOLD = 25
-
 # Maximum loop body size for unrolling consideration
 MAX_UNROLL_LOOP_SIZE = 3
 
@@ -691,70 +570,6 @@ def next_possible_pcs(self, insn, needed_label, nextpc):
     (r'int\((\w+) == (\w+)\) != 0', r'\1 == \2'),  # int(x == y) != 0 -> x == y
 ]
 
-class ValueNumbering(object):
-    """
-    Simple value numbering for common subexpression elimination.
-    Tracks expressions and their computed results within a basic block.
-    """
-    def __init__(self):
-        self.expr_to_value = {}  # (op, arg1, arg2) -> result_register
-        self.value_to_expr = {}  # result_register -> (op, arg1, arg2)
-        self.aliases = {}        # register -> canonical_register (copy propagation)
-
-    def copy(self):
-        """Create a copy for branching paths."""
-        new = ValueNumbering()
-        new.expr_to_value = self.expr_to_value.copy()
-        new.value_to_expr = self.value_to_expr.copy()
-        new.aliases = self.aliases.copy()
-        return new
-
-    def add_alias(self, src, dst):
-        """Record that dst is a copy of src."""
-        canonical = self.get_canonical(src)
-        self.aliases[dst] = canonical
-
-    def get_canonical(self, reg):
-        """Get the canonical register (follow alias chain)."""
-        visited = set()
-        while reg in self.aliases and reg not in visited:
-            visited.add(reg)
-            reg = self.aliases[reg]
-        return reg
-
-    def lookup_expr(self, op, *args):
-        """Check if this expression was already computed."""
-        # Canonicalize arguments
-        canonical_args = tuple(self.get_canonical(a) if not isinstance(a, (int, float, Constant)) else a
-                              for a in args)
-        key = (op,) + canonical_args
-        return self.expr_to_value.get(key)
-
-    def record_expr(self, op, result, *args):
-        """Record that result = op(args)."""
-        canonical_args = tuple(self.get_canonical(a) if not isinstance(a, (int, float, Constant)) else a
-                              for a in args)
-        key = (op,) + canonical_args
-        self.expr_to_value[key] = result
-        self.value_to_expr[result] = key
-
-    def invalidate(self, reg):
-        """Invalidate a register (when it's reassigned)."""
-        canonical = self.get_canonical(reg)
-        # Remove from aliases
-        if reg in self.aliases:
-            del self.aliases[reg]
-        # Remove expressions that use this register
-        to_remove = []
-        for key, val in self.expr_to_value.items():
-            if val == canonical or canonical in key:
-                to_remove.append(key)
-        for key in to_remove:
-            del self.expr_to_value[key]
-        if canonical in self.value_to_expr:
-            del self.value_to_expr[canonical]
-
-
 def _apply_peephole_optimizations(code):
     """
     Apply peephole optimizations to generated Python code.
@@ -1923,9 +1738,6 @@ def _try_inline_chain(self, lines, target_pc, constant_registers, indent):
         prev_insn = None
         prev_result = None
 
-        # Value numbering for CSE and copy propagation
-        value_numbering = ValueNumbering()
-
         while self.inline_depth + len(visited) < MAX_INLINE_DEPTH:
             if current_pc in visited:
                 # Loop detected! Try to generate a tight loop
@@ -1965,7 +1777,7 @@ def _try_inline_chain(self, lines, target_pc, constant_registers, indent):
 
             # Try superinstruction optimization
             superinsn_result = self._try_superinstruction(
-                prev_insn, insn, prev_result, current_const_regs, value_numbering, lines, indent)
+                prev_insn, insn, prev_result, current_const_regs, lines, indent)
             if superinsn_result is not None:
                 # Superinstruction was applied
                 new_const_regs, new_result = superinsn_result
@@ -1997,11 +1809,6 @@ def _try_inline_chain(self, lines, target_pc, constant_registers, indent):
             prev_insn = insn
             if '->' in insn:
                 prev_result = insn[-1]
-                # Record in value numbering for CSE
-                if len(insn) >= 4 and insn[0] in ('int_add', 'int_sub', 'int_mul', 'int_and', 'int_or', 'int_xor'):
-                    value_numbering.record_expr(insn[0], prev_result, insn[1], insn[2])
-                elif insn[0] in ('int_copy', 'ref_copy', 'float_copy'):
-                    value_numbering.add_alias(insn[1], prev_result)
             else:
                 prev_result = None
 
@@ -2028,7 +1835,7 @@ def _try_inline_chain(self, lines, target_pc, constant_registers, indent):
 
         return False
 
-    def _try_superinstruction(self, prev_insn, curr_insn, prev_result, const_regs, value_numbering, lines, indent):
+    def _try_superinstruction(self, prev_insn, curr_insn, prev_result, const_regs, lines, indent):
         """
         Try to apply superinstruction optimization for common patterns.
         Returns (new_const_regs, result_reg) if applied, None otherwise.