feat: update monitor and dfgraph for frame-based PE, FREE_FRAME, act_id, and frame events

dfgraph/categories.py

···
 })
 
 _CONFIG_ROUTING_OPS: frozenset[RoutingOp] = frozenset({
-    RoutingOp.CONST, RoutingOp.FREE_CTX,
+    RoutingOp.CONST, RoutingOp.FREE_FRAME,
 })
 
 

dfgraph/graph_json.py

···
 
 from typing import Any
 
-from cm_inst import Addr, MemOp
+from cm_inst import FrameDest, MemOp
 from asm.ir import (
     IRNode, IREdge, IRGraph, IRRegion, RegionKind,
     SourceLoc, ResolvedDest,
···
     }
 
 
-def _serialise_addr(addr: Addr) -> dict[str, Any]:
+def _serialise_frame_dest(dest: FrameDest) -> dict[str, Any]:
     return {
-        "offset": addr.a,
-        "port": addr.port.name,
-        "pe": addr.pe,
+        "target_pe": dest.target_pe,
+        "offset": dest.offset,
+        "act_id": dest.act_id,
+        "port": dest.port.name,
+        "token_kind": dest.token_kind.name,
     }
 
 
···
         "const": node.const,
         "pe": node.pe,
         "iram_offset": node.iram_offset,
-        "ctx": node.ctx,
+        "act_id": node.act_id,
         "has_error": node.name in error_node_names,
         "loc": _serialise_loc(node.loc),
     }
···
     source_node = all_nodes.get(edge.source)
     if source_node:
         if (isinstance(source_node.dest_l, ResolvedDest)
-                and source_node.dest_l.name == edge.dest):
-            result["addr"] = _serialise_addr(source_node.dest_l.addr)
+                and source_node.dest_l.name == edge.dest
+                and source_node.dest_l.frame_dest is not None):
+            result["frame_dest"] = _serialise_frame_dest(source_node.dest_l.frame_dest)
         elif (isinstance(source_node.dest_r, ResolvedDest)
-                and source_node.dest_r.name == edge.dest):
-            result["addr"] = _serialise_addr(source_node.dest_r.addr)
+                and source_node.dest_r.name == edge.dest
+                and source_node.dest_r.frame_dest is not None):
+            result["frame_dest"] = _serialise_frame_dest(source_node.dest_r.frame_dest)
 
     return result
 
···
             "const": None,
             "pe": None,
             "iram_offset": None,
-            "ctx": None,
+            "act_id": None,
             "has_error": False,
             "loc": {"line": 0, "column": 0, "end_line": None, "end_column": None},
             "sm_id": sm_id,

monitor/formatting.py

···
             event_type = colour("TokenReceived", "bright_cyan")
             return f"{time_str} {event_type} {component_str}: {token}"
 
-        case Matched(left=left, right=right, ctx=ctx, offset=offset):
+        case Matched(left=left, right=right, act_id=act_id, frame_id=frame_id):
             event_type = colour("Matched", "bright_cyan")
             return (
                 f"{time_str} {event_type} {component_str}: "
                 f"left={colour(str(left), 'white')} "
                 f"right={colour(str(right), 'white')} "
-                f"ctx={colour(str(ctx), 'white')} "
-                f"offset={colour(str(offset), 'white')}"
+                f"act_id={colour(str(act_id), 'white')} "
+                f"frame_id={colour(str(frame_id), 'white')}"
             )
 
         case Executed(op=op, result=result, bool_out=bool_out):
···
 def format_pe_state(pe_snapshot: PESnapshot) -> str:
     """Format detailed PE state information (multi-line).
 
-    Shows: IRAM entries, matching store occupancy, gen counters, queue depth, output log length.
+    Shows: IRAM entries, frame state, tag store, free frames, queue depth, output log length.
 
     Args:
         pe_snapshot: PESnapshot instance
···
     else:
         lines.append("  IRAM: (empty)")
 
-    # Matching store occupancy
-    total_occupied = 0
-    for ctx_row in pe_snapshot.matching_store:
-        for entry in ctx_row:
-            if entry.get("occupied", False):
-                total_occupied += 1
-    lines.append(
-        f"  Matching store: {colour(str(total_occupied), 'white')} entries occupied"
-    )
+    # Tag store
+    if pe_snapshot.tag_store:
+        tag_str = ", ".join(
+            f"{colour(str(k), 'white')}: {colour(str(v), 'white')}"
+            for k, v in sorted(pe_snapshot.tag_store.items())
+        )
+        lines.append(f"  Tag store: {{{tag_str}}}")
+    else:
+        lines.append("  Tag store: (empty)")
+
+    # Free frames
+    if pe_snapshot.free_frames:
+        free_str = ", ".join(colour(str(f), "white") for f in pe_snapshot.free_frames)
+        lines.append(f"  Free frames: [{free_str}]")
+    else:
+        lines.append("  Free frames: (none)")
 
-    # Gen counters
-    if pe_snapshot.gen_counters:
-        gens_str = ", ".join(colour(str(g), "white") for g in pe_snapshot.gen_counters)
-        lines.append(f"  Gen counters: [{gens_str}]")
+    # Frames
+    if pe_snapshot.frames:
+        lines.append("  Frames:")
+        for frame_id, frame in enumerate(pe_snapshot.frames):
+            frame_display = []
+            for slot_id, slot_val in enumerate(frame):
+                if slot_val is None:
+                    frame_display.append("None")
+                elif isinstance(slot_val, int):
+                    frame_display.append(colour(str(slot_val), "white"))
+                else:
+                    # FrameDest object
+                    frame_display.append(f"FrameDest(...)")
+            lines.append(
+                f"    Frame {colour(str(frame_id), 'white')}: [{', '.join(frame_display)}]"
+            )
+    else:
+        lines.append("  Frames: (empty)")
 
     # Input queue
     lines.append(

monitor/repl.py

···
             print(format_step_result(result), file=self.stdout)
 
     def do_send(self, arg: str) -> None:
-        """Send token to target: send <target> <offset> <ctx> <data> [--sm <addr> <op>]
+        """Send token to target: send <target> <offset> <act_id> <data> [--sm <addr> <op>]
 
-        For MonadToken: send <target> <offset> <ctx> <data>
+        For MonadToken: send <target> <offset> <act_id> <data>
         For SMToken: send <target> --sm <addr> <op> [<data>]
 
         The --sm flag switches to SMToken mode. op is parsed from MemOp names (READ, WRITE, etc).
···
             return
 
         if not arg:
-            print("Usage: send <target> <offset> <ctx> <data> [--sm <addr> <op>]", file=self.stdout)
+            print("Usage: send <target> <offset> <act_id> <data> [--sm <addr> <op>]", file=self.stdout)
             return
 
         try:
···
             print(f"Sent {token}", file=self.stdout)
 
     def do_inject(self, arg: str) -> None:
-        """Inject token directly (no backpressure): inject <target> <offset> <ctx> <data> [--sm <addr> <op>]
+        """Inject token directly (no backpressure): inject <target> <offset> <act_id> <data> [--sm <addr> <op>]
 
-        For MonadToken: inject <target> <offset> <ctx> <data>
+        For MonadToken: inject <target> <offset> <act_id> <data>
         For SMToken: inject <target> --sm <addr> <op> [<data>]
 
         The --sm flag switches to SMToken mode. op is parsed from MemOp names (READ, WRITE, etc).
···
             return
 
         if not arg:
-            print("Usage: inject <target> <offset> <ctx> <data> [--sm <addr> <op>]", file=self.stdout)
+            print("Usage: inject <target> <offset> <act_id> <data> [--sm <addr> <op>]", file=self.stdout)
             return
 
         try:
···
         """Parse token arguments from command line.
 
         Supports two modes:
-        - MonadToken: <target> <offset> <ctx> <data> [--sm ...]
+        - MonadToken: <target> <offset> <act_id> <data> [--sm ...]
         - SMToken: <target> --sm <addr> <op> [<data>]
 
         Args:
···
         else:
             # MonadToken mode
             if len(parts) < 4:
-                raise ValueError("MonadToken requires <target> <offset> <ctx> <data>")
+                raise ValueError("MonadToken requires <target> <offset> <act_id> <data>")
 
             offset = int(parts[1])
-            ctx = int(parts[2])
+            act_id = int(parts[2])
             data = int(parts[3])
 
-            return MonadToken(target=target, offset=offset, ctx=ctx, data=data, inline=False)
+            return MonadToken(target=target, offset=offset, ctx=act_id, data=data, inline=False)
 
     def do_state(self, arg: str) -> None:
         """Display current simulation state: state

tests/test_dfgraph_categories.py

···
 - ArithOp members map to ARITHMETIC
 - LogicOp logic ops map to LOGIC
 - LogicOp comparison ops map to COMPARISON
-- RoutingOp members (except CONST/FREE_CTX) map to ROUTING
-- RoutingOp.CONST and FREE_CTX map to CONFIG
+- RoutingOp members (except CONST/FREE_FRAME) map to ROUTING
+- RoutingOp.CONST and FREE_FRAME map to CONFIG
 - MemOp members map to MEMORY
 - Every OpcodeCategory has a colour in CATEGORY_COLOURS
 """
···
         ArithOp.SUB,
         ArithOp.INC,
         ArithOp.DEC,
-        ArithOp.SHIFT_L,
-        ArithOp.SHIFT_R,
-        ArithOp.ASHFT_R,
+        ArithOp.SHL,
+        ArithOp.SHR,
+        ArithOp.ASR,
     ])
     def test_arith_ops_map_to_arithmetic(self, op):
         """All ArithOp members map to ARITHMETIC category."""
···
 
     @pytest.mark.parametrize("op", [
         RoutingOp.CONST,
-        RoutingOp.FREE_CTX,
+        RoutingOp.FREE_FRAME,
     ])
     def test_config_routing_ops_map_to_config(self, op):
-        """RoutingOp.CONST and RoutingOp.FREE_CTX map to CONFIG category."""
+        """RoutingOp.CONST and RoutingOp.FREE_FRAME map to CONFIG category."""
         assert categorise(op) == OpcodeCategory.CONFIG
 
 

tests/test_dfgraph_json.py

···
         assert result_node["category"] == "arithmetic"
         assert result_node["pe"] == 0
         assert result_node["iram_offset"] is not None
-        assert result_node["ctx"] is not None
+        assert result_node["act_id"] is not None
         assert result_node["has_error"] is False
 
         # Verify edges are present
···
         # Note: pe is set by explicit placement, iram_offset and ctx are set by allocate
         for node in json_out["nodes"]:
             assert node["iram_offset"] is None
-            assert node["ctx"] is None
+            assert node["act_id"] is None
 
         # Error list should be populated
         assert len(json_out["errors"]) > 0
···
 
         node = json_out["nodes"][0]
         required_fields = {"id", "opcode", "category", "colour", "const", "pe",
-                          "iram_offset", "ctx", "has_error", "loc"}
+                          "iram_offset", "act_id", "has_error", "loc"}
         assert set(node.keys()) >= required_fields
 
         # Location should have required fields

tests/test_monitor_graph_json.py

···
 - or1-monitor.AC3.8: SM state serialization
 """
 
-from cm_inst import ArithOp, MemOp, Port, Addr, ALUInst
+from cm_inst import ArithOp, MemOp, Port, FrameDest, Instruction, OutputStyle
 from asm.ir import IRGraph, IRNode, IREdge, SourceLoc, SystemConfig
 from emu.events import TokenReceived, Matched, Executed, Emitted
 from monitor.graph_json import graph_to_monitor_json, graph_loaded_json
···
             opcode=ArithOp.ADD,
             pe=0,
             iram_offset=0,
-            ctx=0,
+            act_id=0,
             loc=SourceLoc(1, 1),
         )
         ir_graph = IRGraph(
···
             system=SystemConfig(pe_count=1, sm_count=0),
         )
 
-        # Create ALUInst for IRAM
-        inst = ALUInst(op=ArithOp.ADD, dest_l=None, dest_r=None, const=None)
+        # Create Instruction for IRAM
+        inst = Instruction(opcode=ArithOp.ADD, output=OutputStyle.INHERIT, has_const=False, dest_count=2, wide=False, fref=0)
 
         # Create minimal snapshot
         pe_snap = PESnapshot(
             pe_id=0,
             iram={0: inst},
-            matching_store=(),
-            gen_counters=(),
+            frames=(),
+            tag_store={},
+            presence=(),
+            port_store=(),
+            free_frames=(),
             input_queue=(),
             output_log=(),
         )
···
             opcode=ArithOp.ADD,
             pe=0,
             iram_offset=5,
-            ctx=1,
+            act_id=1,
             const=42,
             loc=SourceLoc(1, 1),
         )
···
             system=SystemConfig(pe_count=1, sm_count=0),
         )
 
-        inst = ALUInst(op=ArithOp.ADD, dest_l=None, dest_r=None, const=None)
+        inst = Instruction(opcode=ArithOp.ADD, output=OutputStyle.INHERIT, has_const=False, dest_count=2, wide=False, fref=0)
         pe_snap = PESnapshot(
             pe_id=0,
             iram={5: inst},
-            matching_store=(),
-            gen_counters=(),
+            frames=(),
+            tag_store={},
+            presence=(),
+            port_store=(),
+            free_frames=(),
             input_queue=(),
             output_log=(),
         )
···
         assert node_json["opcode"] == "add"
         assert node_json["pe"] == 0
         assert node_json["iram_offset"] == 5
-        assert node_json["ctx"] == 1
+        assert node_json["act_id"] == 1
         assert node_json["const"] == 42
         # Check execution overlay fields are present and False
         assert node_json["active"] is False
···
             opcode=ArithOp.ADD,
             pe=0,
             iram_offset=5,
-            ctx=1,
+            act_id=1,
         )
         ir_graph = IRGraph(nodes={"&add": node})
 
-        inst = ALUInst(op=ArithOp.ADD, dest_l=None, dest_r=None, const=None)
+        inst = Instruction(opcode=ArithOp.ADD, output=OutputStyle.INHERIT, has_const=False, dest_count=2, wide=False, fref=0)
         pe_snap = PESnapshot(
             pe_id=0,
             iram={5: inst},
-            matching_store=(),
-            gen_counters=(0, 1, 2),
+            frames=(),
+            tag_store={},
+            presence=(),
+            port_store=(),
+            free_frames=(),
             input_queue=(),
             output_log=(),
         )
···
         pe_state = result["state"]["pes"]["0"]
 
         assert "iram" in pe_state
-        assert "matching_store" in pe_state
-        assert "gen_counters" in pe_state
-        assert pe_state["gen_counters"] == [0, 1, 2]
-        assert pe_state["input_queue_depth"] == 0
-        assert pe_state["output_count"] == 0
+        assert "frames" in pe_state
+        assert "tag_store" in pe_state
+        assert "free_frames" in pe_state
+        assert pe_state["input_queue_size"] == 0
 
     def test_graph_loaded_json_sm_state(self):
         """Test SM state serialization."""
···
             opcode=ArithOp.ADD,
             pe=0,
             iram_offset=0,
-            ctx=0,
+            act_id=0,
         )
         ir_graph = IRGraph(nodes={"&add": node})
 
-        token = DyadToken(target=0, offset=0, ctx=0, data=42, port=Port.L, gen=0, wide=False)
+        token = DyadToken(target=0, offset=0, act_id=0, data=42, port=Port.L)
         event = TokenReceived(time=1.0, component="pe:0", token=token)
 
-        inst = ALUInst(op=ArithOp.ADD, dest_l=None, dest_r=None, const=None)
+        inst = Instruction(opcode=ArithOp.ADD, output=OutputStyle.INHERIT, has_const=False, dest_count=2, wide=False, fref=0)
         pe_snap = PESnapshot(
             pe_id=0,
             iram={0: inst},
-            matching_store=(),
-            gen_counters=(),
+            frames=(),
+            tag_store={},
+            presence=(),
+            port_store=(),
+            free_frames=(),
             input_queue=(),
             output_log=(),
         )
···
             opcode=ArithOp.ADD,
             pe=0,
             iram_offset=5,
-            ctx=0,
+            act_id=0,
         )
         ir_graph = IRGraph(nodes={"&add": node})
 
-        event = Matched(time=1.0, component="pe:0", left=42, right=7, ctx=0, offset=5)
+        event = Matched(time=1.0, component="pe:0", left=42, right=7, act_id=0, offset=5, frame_id=0)
 
-        inst = ALUInst(op=ArithOp.ADD, dest_l=None, dest_r=None, const=None)
+        inst = Instruction(opcode=ArithOp.ADD, output=OutputStyle.INHERIT, has_const=False, dest_count=2, wide=False, fref=0)
         pe_snap = PESnapshot(
             pe_id=0,
             iram={5: inst},
-            matching_store=(),
-            gen_counters=(),
+            frames=(),
+            tag_store={},
+            presence=(),
+            port_store=(),
+            free_frames=(),
             input_queue=(),
             output_log=(),
         )
···
             opcode=ArithOp.ADD,
             pe=0,
             iram_offset=0,
-            ctx=0,
+            act_id=0,
         )
         ir_graph = IRGraph(nodes={"&add": node})
 
         event = Executed(time=1.0, component="pe:0", op=ArithOp.ADD, result=49, bool_out=False)
 
-        inst = ALUInst(op=ArithOp.ADD, dest_l=None, dest_r=None, const=None)
+        inst = Instruction(opcode=ArithOp.ADD, output=OutputStyle.INHERIT, has_const=False, dest_count=2, wide=False, fref=0)
         pe_snap = PESnapshot(
             pe_id=0,
             iram={0: inst},
-            matching_store=(),
-            gen_counters=(),
+            frames=(),
+            tag_store={},
+            presence=(),
+            port_store=(),
+            free_frames=(),
             input_queue=(),
             output_log=(),
         )
···
     def test_monitor_json_events_serialization(self):
         """Test events are properly serialized."""
         ir_graph = IRGraph()
-        token = DyadToken(target=0, offset=0, ctx=0, data=42, port=Port.L, gen=0, wide=False)
+        token = DyadToken(target=0, offset=0, act_id=0, data=42, port=Port.L)
         events = [
             TokenReceived(time=1.0, component="pe:0", token=token),
             Executed(time=1.1, component="pe:0", op=ArithOp.ADD, result=49, bool_out=False),
···
             opcode=ArithOp.ADD,
             pe=0,
             iram_offset=0,
-            ctx=0,
+            act_id=0,
         )
         dest = IRNode(
             name="&b",
             opcode=ArithOp.SUB,
             pe=0,
             iram_offset=1,
-            ctx=0,
+            act_id=0,
         )
         edge = IREdge(
             source="&a",
···
             opcode=ArithOp.ADD,
             pe=0,
             iram_offset=0,
-            ctx=0,
+            act_id=0,
         )
         dest = IRNode(
             name="&b",
             opcode=ArithOp.SUB,
             pe=1,  # Destination on a different PE
             iram_offset=1,
-            ctx=0,
+            act_id=0,
         )
         edge = IREdge(source="&a", dest="&b", port=Port.L)
         ir_graph = IRGraph(
···
         )
 
         # Emitted event with token targeting PE 1 should mark the edge
-        token = DyadToken(target=1, offset=1, ctx=0, data=42, port=Port.L, gen=0, wide=False)
+        token = DyadToken(target=1, offset=1, act_id=0, data=42, port=Port.L)
         event = Emitted(time=1.0, component="pe:0", token=token)
 
         snapshot = StateSnapshot(

tests/test_snapshot.py

···
 import pytest
 import simpy
 
-from cm_inst import ALUInst, ArithOp, MemOp, Port, RoutingOp, SMInst, Addr
+from cm_inst import Instruction, ArithOp, MemOp, Port, RoutingOp, OutputStyle
 from emu.network import build_topology
 from emu.types import PEConfig, SMConfig
 from monitor.snapshot import capture, PESnapshot, SMSnapshot, SMCellSnapshot
···
         env = simpy.Environment()
 
         # Create one PE with a simple CONST instruction
-        iram = {0: ALUInst(RoutingOp.CONST, None, None, const=42)}
+        iram = {0: Instruction(opcode=RoutingOp.CONST, output=OutputStyle.SINK, has_const=True, dest_count=0, wide=False, fref=0)}
         pe_configs = [PEConfig(pe_id=0, iram=iram)]
         sm_configs = []
 
         system = build_topology(env, pe_configs, sm_configs)
 
         # Inject a seed token
-        seed = MonadToken(target=0, offset=0, ctx=0, data=0, inline=True)
+        seed = MonadToken(target=0, offset=0, act_id=0, data=0, inline=True)
         system.inject(seed)
 
         snapshot = capture(system)
···
         # Verify IRAM is captured
         assert pe_snap.iram == iram
 
-        # Verify matching store and gen counters are initialized
-        assert len(pe_snap.gen_counters) > 0
-        assert len(pe_snap.matching_store) > 0
+        # Verify frame-based state is initialized
+        assert hasattr(pe_snap, 'frames')
+        assert hasattr(pe_snap, 'tag_store')
 
     def test_capture_sm_with_written_cells(self):
         """Test capturing SM state with written cells."""
···
         """Test that PE matching store is captured with correct structure."""
         env = simpy.Environment()
 
-        iram = {0: ALUInst(ArithOp.ADD, Addr(0, Port.L, 0), Addr(0, Port.R, 0), None)}
+        iram = {0: Instruction(opcode=ArithOp.ADD, output=OutputStyle.INHERIT, has_const=False, dest_count=2, wide=False, fref=0)}
         pe_configs = [PEConfig(pe_id=0, iram=iram, frame_count=4, offsets=64)]
         sm_configs = []
 
···
         """Test that PE output_log is captured."""
         env = simpy.Environment()
 
-        iram = {0: ALUInst(RoutingOp.CONST, Addr(0, Port.L, 0), None, const=99)}
+        iram = {0: Instruction(opcode=RoutingOp.CONST, output=OutputStyle.SINK, has_const=True, dest_count=0, wide=False, fref=0)}
         pe_configs = [PEConfig(pe_id=0, iram=iram)]
         sm_configs = []
 
         system = build_topology(env, pe_configs, sm_configs)
 
         # Manually add a token to output_log to simulate emission
-        output_token = MonadToken(target=0, offset=1, ctx=0, data=99, inline=True)
+        output_token = MonadToken(target=0, offset=1, act_id=0, data=99, inline=True)
         system.pes[0].output_log.append(output_token)
 
         snapshot = capture(system)
···
         """Test that PE generation counters are captured."""
         env = simpy.Environment()
 
-        iram = {0: ALUInst(RoutingOp.CONST, None, None, const=1)}
+        iram = {0: Instruction(opcode=RoutingOp.CONST, output=OutputStyle.SINK, has_const=True, dest_count=0, wide=False, fref=0)}
         pe_configs = [PEConfig(pe_id=0, iram=iram)]
         system = build_topology(env, pe_configs, [])
 
···
 
         sm = system.sms[0]
         # Manually set up a deferred read (in real code this happens during simulation)
-        return_token = MonadToken(target=0, offset=0, ctx=0, data=0, inline=False)
+        return_token = MonadToken(target=0, offset=0, act_id=0, data=0, inline=False)
         from emu.types import DeferredRead
         sm.deferred_read = DeferredRead(cell_addr=42, return_route=return_token)
 
···
 
         sm = system.sms[0]
         # Add some tokens to T0 store
-        token1 = MonadToken(target=0, offset=5, ctx=0, data=777, inline=True)
-        token2 = MonadToken(target=0, offset=6, ctx=0, data=888, inline=True)
+        token1 = MonadToken(target=0, offset=5, act_id=0, data=777, inline=True)
+        token2 = MonadToken(target=0, offset=6, act_id=0, data=888, inline=True)
         sm.t0_store.append(token1)
         sm.t0_store.append(token2)
 
···
         env = simpy.Environment()
 
         pe_configs = [
-            PEConfig(pe_id=0, iram={0: ALUInst(RoutingOp.CONST, None, None, const=1)}),
-            PEConfig(pe_id=1, iram={0: ALUInst(RoutingOp.CONST, None, None, const=2)}),
+            PEConfig(pe_id=0, iram={0: Instruction(opcode=RoutingOp.CONST, output=OutputStyle.SINK, has_const=True, dest_count=0, wide=False, fref=0)}),
+            PEConfig(pe_id=1, iram={0: Instruction(opcode=RoutingOp.CONST, output=OutputStyle.SINK, has_const=True, dest_count=0, wide=False, fref=0)}),
         ]
         sm_configs = [
             SMConfig(sm_id=0, cell_count=256),
···
         assert initial_snapshot.next_time == float('inf')
 
         # Create a PE and add it to trigger time advancement
-        iram = {0: ALUInst(RoutingOp.CONST, None, None, const=1)}
+        iram = {0: Instruction(opcode=RoutingOp.CONST, output=OutputStyle.SINK, has_const=True, dest_count=0, wide=False, fref=0)}
         pe_configs = [PEConfig(pe_id=0, iram=iram)]
         env2 = simpy.Environment()
         system2 = build_topology(env2, pe_configs, [])