feat[venom]: scheduler optimization

vyper/utils.py

@@ -591,3 +591,34 @@ def annotate_source_code(
     cleanup_lines += [""] * (num_lines - len(cleanup_lines))
 
     return "\n".join(cleanup_lines)
+
+
+def find_cycles_in_directed_graph(graph):
+    visit_state = {}  # Visit states: 0 = Not visited, 1 = Visiting, 2 = Visited
+    stack = []  # Stack to keep track of the current path
+    all_cycles = []  # List to store all detected cycles
+
+    def dfs(node):
+        vs = visit_state.get(node, 0)
+        if vs == 1:  # Cycle detected
+            cycle_index = stack.index(node)
+            cycle_nodes = stack[cycle_index:]
+            all_cycles.append(cycle_nodes)
+            return
+        elif vs == 2:  # Already fully visited
+            return
+
+        visit_state[node] = 1
+        stack.append(node)
+
+        for neighbor in graph.get(node, []):
+            dfs(neighbor)
+
+        stack.pop()
+        visit_state[node] = 2
+
+    for node in graph:
+        if visit_state.get(node, 0) == 0:
+            dfs(node)
+
+    return all_cycles

vyper/venom/__init__.py

@@ -6,6 +6,8 @@
 from vyper.codegen.ir_node import IRnode
 from vyper.compiler.settings import OptimizationLevel
 from vyper.venom.analysis.analysis import IRAnalysesCache
+from vyper.venom.analysis.dfg import DFGAnalysis
+from vyper.venom.analysis.liveness import LivenessAnalysis
 from vyper.venom.context import IRContext
 from vyper.venom.function import IRFunction
 from vyper.venom.ir_node_to_venom import ir_node_to_venom
@@ -39,6 +41,9 @@
     return compiler.generate_evm(optimize == OptimizationLevel.NONE)
 
 
+count = 0
+
+
 def _run_passes(fn: IRFunction, optimize: OptimizationLevel) -> None:
     # Run passes on Venom IR
     # TODO: Add support for optimization levels
@@ -56,7 +61,18 @@
     BranchOptimizationPass(ac, fn).run_pass()
     ExtractLiteralsPass(ac, fn).run_pass()
     RemoveUnusedVariablesPass(ac, fn).run_pass()
-    DFTPass(ac, fn).run_pass()
+    dft = DFTPass(ac, fn)
+    dft.run_pass()
+
+    # ac.force_analysis(LivenessAnalysis)
+    # global count
+    # if count == 1:
+    #     #dft = ac.request_analysis(DFGAnalysis)
+    #     print(dft.ida_as_graph())
+
+    #     import sys
+    #     sys.exit(1)
+    # count += 1
 
 
 def generate_ir(ir: IRnode, optimize: OptimizationLevel) -> IRContext:

vyper/venom/analysis/analysis.py

@@ -50,9 +50,9 @@ def request_analysis(self, analysis_cls: Type[IRAnalysis], *args, **kwargs):
         if analysis_cls in self.analyses_cache:
             return self.analyses_cache[analysis_cls]
         analysis = analysis_cls(self, self.function)
+        self.analyses_cache[analysis_cls] = analysis
         analysis.analyze(*args, **kwargs)
 
-        self.analyses_cache[analysis_cls] = analysis
         return analysis
 
     def invalidate_analysis(self, analysis_cls: Type[IRAnalysis]):

vyper/venom/analysis/cfg.py

@@ -18,7 +18,7 @@ def analyze(self) -> None:
         for bb in fn.get_basic_blocks():
             assert len(bb.instructions) > 0, "Basic block should not be empty"
             last_inst = bb.instructions[-1]
-            assert last_inst.is_bb_terminator, f"Last instruction should be a terminator {bb}"
+            assert last_inst.is_bb_terminator, "Last instruction should be a terminator"
 
             for inst in bb.instructions:
                 if inst.opcode in CFG_ALTERING_INSTRUCTIONS:

vyper/venom/basicblock.py

@@ -211,7 +211,6 @@ class IRInstruction:
     liveness: OrderedSet[IRVariable]
     dup_requirements: OrderedSet[IRVariable]
     parent: "IRBasicBlock"
-    fence_id: int
     annotation: Optional[str]
     ast_source: Optional[IRnode]
     error_msg: Optional[str]
@@ -229,7 +228,6 @@ def __init__(
         self.output = output
         self.liveness = OrderedSet()
         self.dup_requirements = OrderedSet()
-        self.fence_id = -1
         self.annotation = None
         self.ast_source = None
         self.error_msg = None
@@ -242,6 +240,10 @@ def is_volatile(self) -> bool:
     def is_bb_terminator(self) -> bool:
         return self.opcode in BB_TERMINATORS
 
+    @property
+    def is_phi(self) -> bool:
+        return self.opcode == "phi"
+
     def get_label_operands(self) -> Iterator[IRLabel]:
         """
         Get all labels in instruction.
@@ -321,6 +323,20 @@ def get_ast_source(self) -> Optional[IRnode]:
                 return inst.ast_source
         return self.parent.parent.ast_source
 
+    def str_short(self) -> str:
+        s = ""
+        if self.output:
+            s += f"{self.output} = "
+        opcode = f"{self.opcode} " if self.opcode != "store" else ""
+        s += opcode
+        operands = self.operands
+        if opcode not in ["jmp", "jnz", "invoke"]:
+            operands = list(reversed(operands))
+        s += ", ".join(
+            [(f"label %{op}" if isinstance(op, IRLabel) else str(op)) for op in operands]
+        )
+        return s
+
     def __repr__(self) -> str:
         s = ""
         if self.output:
@@ -337,10 +353,7 @@ def __repr__(self) -> str:
         if self.annotation:
             s += f" <{self.annotation}>"
 
-        if self.liveness:
-            return f"{s: <30} # {self.liveness}"
-
-        return s
+        return f"{s: <30} # {self.liveness}"
 
 
 def _ir_operand_from_value(val: Any) -> IROperand:
@@ -479,6 +492,22 @@ def remove_instruction(self, instruction: IRInstruction) -> None:
     def clear_instructions(self) -> None:
         self.instructions = []
 
+    @property
+    def non_phi_instructions(self) -> Iterator[IRInstruction]:
+        return (inst for inst in self.instructions if inst.opcode != "phi")
+
+    @property
+    def phi_instructions(self) -> Iterator[IRInstruction]:
+        for inst in self.instructions:
+            if inst.opcode == "phi":
+                yield inst
+            else:
+                return
+
+    @property
+    def body_instructions(self) -> Iterator[IRInstruction]:
+        return (inst for inst in self.instructions[:-1] if inst.opcode != "phi")
+
     def replace_operands(self, replacements: dict) -> None:
         """
         Update operands with replacements.