Revert "[When] Split when blocks with cycles (#1309)"

This reverts commit 512c7e1.

magma/backend/mlir/build_magma_graph.py

@@ -176,11 +176,24 @@ def _visit_inputs(
         )
 
 
+def _check_for_when_cycles(graph: Graph):
+    """Temporary guard against https://github.com/phanrahan/magma/issues/1248"""
+    for node in graph.nodes():
+        if not iswhen(node):
+            continue
+        for predecessor in graph.predecessors(node):
+            if isinstance(type(node), Register):  # registers break cycles
+                break
+            if predecessor is node:
+                raise MlirWhenCycleError()
+
+
 def build_magma_graph(
         ckt: DefineCircuitKind,
         opts: BuildMagmaGrahOpts = BuildMagmaGrahOpts()) -> Graph:
     ctx = ModuleContext(Graph(), opts)
     _visit_inputs(ctx, ckt, opts.flatten_all_tuples)
     for inst in ckt.instances:
         _visit_inputs(ctx, inst, opts.flatten_all_tuples)
+    _check_for_when_cycles(ctx.graph)
     return ctx.graph

magma/passes/when.py

@@ -1,13 +1,11 @@
 from magma.passes.passes import DefinitionPass, pass_lambda
-from magma.passes.split_when_utils import split_when_cycles
 from magma.primitives.when import WhenBuilder
-from magma.when import WhenBlock
 
 
 class WhenPass(DefinitionPass):
     def __call__(self, definition):
         with definition.open():
-            for builder in list(definition._context_._builders):
+            for builder in definition._context_._builders:
                 if isinstance(builder, WhenBuilder):
                     self.process_when_builder(builder, definition)
 
@@ -26,11 +24,6 @@ def process_when_builder(self, builder, defn):
         builder.emit_when_assertions(self._flatten_all_tuples)
 
 
-class SplitCycles(WhenPass):
-    def process_when_builder(self, builder, defn):
-        split_when_cycles(builder, defn)
-
-
 class FinalizeWhens(WhenPass):
     def process_when_builder(self, builder, defn):
         assert not builder._finalized
@@ -39,7 +32,6 @@ def process_when_builder(self, builder, defn):
 
 infer_latch_pass = pass_lambda(InferLatches)
 emit_when_assert_pass = pass_lambda(EmitWhenAsserts)
-split_cycles_pass = pass_lambda(SplitCycles)
 finalize_when_pass = pass_lambda(FinalizeWhens)
 
 
@@ -51,5 +43,4 @@ def run_when_passes(
     infer_latch_pass(main)
     if emit_when_assertions:
         emit_when_assert_pass(main, flatten_all_tuples)
-    split_cycles_pass(main)
     finalize_when_pass(main)

magma/primitives/when.py

@@ -168,10 +168,6 @@ def output_to_index(self) -> Dict[Type, int]:
     def output_to_name(self):
         return self._output_to_name
 
-    @property
-    def input_to_name(self):
-        return self._input_to_name
-
     def check_existing_derived_ref(self, value, value_to_name, value_to_index):
         """If value is a child of an array or tuple that has already been added,
         we return the child of the existing value, rather than adding a new

magma/when.py

@@ -70,14 +70,14 @@ class ConditionalWire:
 
 
 class _BlockBase(contextlib.AbstractContextManager):
-    def __init__(self, parent: Optional['WhenBlock']):
+    def __init__(self, parent: Optional['_WhenBlock']):
         self._parent = parent
         self._children = list()
         self._conditional_wires = list()
         self._default_drivers = dict()
 
-    def spawn(self, info: '_WhenBlockInfo') -> 'WhenBlock':
-        child = WhenBlock(self, info)
+    def spawn(self, info: '_WhenBlockInfo') -> '_WhenBlock':
+        child = _WhenBlock(self, info)
         self._children.append(child)
         return child
 
@@ -108,7 +108,7 @@ def add_conditional_wire(self, i, o):
 
     @property
     @abc.abstractmethod
-    def root(self) -> 'WhenBlock':
+    def root(self) -> '_WhenBlock':
         raise NotImplementedError()
 
     @abc.abstractmethod
@@ -252,7 +252,7 @@ class _ElseWhenBlockInfo(_WhenBlockInfo):
     pass
 
 
-class WhenBlock(_BlockBase):
+class _WhenBlock(_BlockBase):
     def __init__(
             self,
             parent: Optional[_BlockBase],
@@ -272,14 +272,14 @@ def __init__(
                 self._builder.debug_info = debug_info
 
     def new_elsewhen_block(self, info: '_ElseWhenBlockInfo'):
-        block = ElseWhenBlock(self, info)
+        block = _ElseWhenBlock(self, info)
         self._elsewhens.append(block)
         return block
 
     def new_otherwise_block(self):
         if self._otherwise is not None:
             raise WhenSyntaxError()
-        block = OtherwiseBlock(self)
+        block = _OtherwiseBlock(self)
         self._otherwise = block
         return block
 
@@ -290,7 +290,7 @@ def builder(self) -> Any:
         return self._builder
 
     @property
-    def root(self) -> 'WhenBlock':
+    def root(self) -> '_WhenBlock':
         if self._parent is None:
             return self
         return self._parent.root
@@ -316,7 +316,7 @@ def _get_exit_block(self):
         return self._parent
 
 
-class ElseWhenBlock(_BlockBase):
+class _ElseWhenBlock(_BlockBase):
     def __init__(self, parent: Optional[_BlockBase], info: _ElseWhenBlockInfo):
         super().__init__(parent)
         self._info = info
@@ -328,7 +328,7 @@ def new_otherwise_block(self):
         return self._parent.new_otherwise_block()
 
     @property
-    def root(self) -> WhenBlock:
+    def root(self) -> _WhenBlock:
         return self._parent.root
 
     @property
@@ -346,15 +346,15 @@ def _get_exit_block(self):
         return self._parent._get_exit_block()
 
 
-class OtherwiseBlock(_BlockBase):
+class _OtherwiseBlock(_BlockBase):
     def new_elsewhen_block(self, _):
         raise ElsewhenWithoutPrecedingWhenError()
 
     def new_otherwise_block(self):
         raise OtherwiseWithoutPrecedingWhenError()
 
     @property
-    def root(self) -> WhenBlock:
+    def root(self) -> _WhenBlock:
         return self._parent.root
 
     @property
@@ -434,18 +434,18 @@ def _reset_context():
 
 
 def _get_else_block(block: _BlockBase) -> Optional[_BlockBase]:
-    if isinstance(block, OtherwiseBlock):
+    if isinstance(block, _OtherwiseBlock):
         return None
-    if isinstance(block, ElseWhenBlock):
-        # TODO(rsetaluri): We could augment ElseWhenBlock to keep track of its
+    if isinstance(block, _ElseWhenBlock):
+        # TODO(rsetaluri): We could augment _ElseWhenBlock to keep track of its
         # index in the parent block, or alternatively keep an explicit pointer
-        # to the next else/otherwise block in each ElseWhenBlock.
+        # to the next else/otherwise block in each _ElseWhenBlock.
         parent_elsewhen_blocks = list(block._parent.elsewhen_blocks())
         index = parent_elsewhen_blocks.index(block) + 1
         if index == len(parent_elsewhen_blocks):
             return block._parent.otherwise_block
         return parent_elsewhen_blocks[index]
-    if isinstance(block, WhenBlock):
+    if isinstance(block, _WhenBlock):
         try:
             else_block = next(block.elsewhen_blocks())
         except StopIteration:
@@ -464,9 +464,9 @@ def _get_then_ops(block: _BlockBase) -> Iterable[_Op]:
 
 
 def _get_else_ops(block: _BlockBase) -> Iterable[_Op]:
-    if isinstance(block, OtherwiseBlock):
+    if isinstance(block, _OtherwiseBlock):
         return _get_then_ops(block)
-    if isinstance(block, ElseWhenBlock):
+    if isinstance(block, _ElseWhenBlock):
         return (block,)
     raise TypeError(block)
 
@@ -535,7 +535,7 @@ def _get_assignees_and_latches(ops: Iterable[_Op]) -> Tuple[Set, Set]:
 
 
 def find_inferred_latches(block: _BlockBase) -> Set:
-    if not (isinstance(block, WhenBlock) and block.root is block):
+    if not (isinstance(block, _WhenBlock) and block.root is block):
         raise TypeError("Can only find inferred latches on root when block")
     ops = tuple(block.default_drivers()) + (block,)
     _, latches = _get_assignees_and_latches(ops)
@@ -676,7 +676,7 @@ def when(cond):
     info = _WhenBlockInfo(cond)
     curr_block = _get_curr_block()
     if curr_block is None:
-        return WhenBlock(None, info, get_debug_info(3))
+        return _WhenBlock(None, info, get_debug_info(3))
     return curr_block.spawn(info)
 
 

magma/wire_container.py

@@ -329,9 +329,6 @@ def has_elaborated_children(self):
     def _enumerate_children(self):
         raise NotImplementedError()
 
-    def enumerate_children(self):
-        return self._enumerate_children()
-
     def _get_conditional_drivee_info(self):
         """
         * wired_when_contexts: list of contexts in which this value appears as