feat[venom]: multidimensional fencing

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

vyper/venom/passes/dft.py

@@ -1,23 +1,115 @@
+from dataclasses import asdict, dataclass
+
 from vyper.utils import OrderedSet
+from vyper.venom.analysis.cfg import CFGAnalysis
 from vyper.venom.analysis.dfg import DFGAnalysis
+from vyper.venom.analysis.liveness import LivenessAnalysis
 from vyper.venom.basicblock import IRBasicBlock, IRInstruction, IRVariable
 from vyper.venom.function import IRFunction
 from vyper.venom.passes.base_pass import IRPass
 
+_ALL = ("storage", "transient", "memory", "immutables")
+
+writes = {
+    "sstore": "storage",
+    "tstore": "transient",
+    "mstore": "memory",
+    "istore": "immutables",
+    "delegatecall": _ALL,
+    "call": _ALL,
+    "create": _ALL,
+    "create2": _ALL,
+    "invoke": _ALL,  # could be smarter, look up the effects of the invoked function
+    "staticcall": "memory",
+    "dloadbytes": "memory",
+    "returndatacopy": "memory",
+    "calldatacopy": "memory",
+    "codecopy": "memory",
+    "extcodecopy": "memory",
+    "mcopy": "memory",
+}
+reads = {
+    "sload": "storage",
+    "tload": "transient",
+    "iload": "immutables",
+    "mstore": "memory",
+    "mcopy": "memory",
+    "call": _ALL,
+    "delegatecall": _ALL,
+    "staticcall": _ALL,
+    "log": "memory",
+    "revert": "memory",
+    "return": "memory",
+    "sha3": "memory",
+}
+
+
+@dataclass
+class Fence:
+    storage: int = 0
+    memory: int = 0
+    transient: int = 0
+    immutables: int = 0
+
+
+def _compute_fence(opcode: str, fence: Fence) -> Fence:
+    if opcode not in writes:
+        return fence
+
+    effects = get_writes(opcode)
+
+    tmp = asdict(fence)
+    for eff in effects:
+        tmp[eff] += 1
+
+    return Fence(**tmp)
+
+
+def get_reads(opcode):
+    ret = reads.get(opcode, ())
+    if not isinstance(ret, tuple):
+        ret = (ret,)
+    return ret
+
+
+def get_writes(opcode):
+    ret = writes.get(opcode, ())
+    if not isinstance(ret, tuple):
+        ret = (ret,)
+    return ret
+
+
+def _can_reorder(inst1, inst2):
+    if inst1.parent != inst2.parent:
+        return False
+
+    effects = (
+        get_reads(inst1.opcode)
+        + get_reads(inst2.opcode)
+        + get_writes(inst1.opcode)
+        + get_writes(inst2.opcode)
+    )
+
+    for eff in effects:
+        if getattr(inst1.fence, eff) != getattr(inst2.fence, eff):  # type: ignore
+            return False
+
+    return True
+
 
 class DFTPass(IRPass):
     function: IRFunction
     inst_order: dict[IRInstruction, int]
     inst_order_num: int
+    fence: Fence
 
     def _process_instruction_r(self, bb: IRBasicBlock, inst: IRInstruction, offset: int = 0):
         for op in inst.get_outputs():
             assert isinstance(op, IRVariable), f"expected variable, got {op}"
             uses = self.dfg.get_uses(op)
 
             for uses_this in uses:
-                if uses_this.parent != inst.parent or uses_this.fence_id != inst.fence_id:
-                    # don't reorder across basic block or fence boundaries
+                if not _can_reorder(inst, uses_this):
                     continue
 
                 # if the instruction is a terminator, we need to place
@@ -43,20 +135,17 @@
         for op in inst.get_input_variables():
             target = self.dfg.get_producing_instruction(op)
             assert target is not None, f"no producing instruction for {op}"
-            if target.parent != inst.parent or target.fence_id != inst.fence_id:
-                # don't reorder across basic block or fence boundaries
+            if not _can_reorder(target, inst):
                 continue
+
             self._process_instruction_r(bb, target, offset)
 
         self.inst_order[inst] = self.inst_order_num + offset
 
     def _process_basic_block(self, bb: IRBasicBlock) -> None:
-        self.function.append_basic_block(bb)
-
         for inst in bb.instructions:
-            inst.fence_id = self.fence_id
-            if inst.is_volatile:
-                self.fence_id += 1
+            inst.fence = self.fence  # type: ignore
+            self.fence = _compute_fence(inst.opcode, self.fence)
 
         # We go throught the instructions and calculate the order in which they should be executed
         # based on the data flow graph. This order is stored in the inst_order dictionary.
@@ -71,11 +160,12 @@
     def run_pass(self) -> None:
         self.dfg = self.analyses_cache.request_analysis(DFGAnalysis)
 
-        self.fence_id = 0
+        self.fence = Fence()
         self.visited_instructions: OrderedSet[IRInstruction] = OrderedSet()
 
         basic_blocks = list(self.function.get_basic_blocks())
 
-        self.function.clear_basic_blocks()
         for bb in basic_blocks:
             self._process_basic_block(bb)
+
+        self.analyses_cache.invalidate_analysis(LivenessAnalysis)