test: add tests for ALLOC_SHARED, FREE_LANE, and lane exhaustion

Verifies frame-lanes.AC3.1, AC3.2, AC3.6, AC8.1, AC8.2:
- AC3.1: ALLOC_SHARED assigns next free lane from parent frame
- AC3.2: FREE_LANE clears lane data, keeps frame
- AC3.6: Lane exhaustion emits TokenRejected with 'no free lanes'
- AC8.1: Two act_ids sharing a frame have independent matching
- AC8.2: ALLOC_SHARED with exhausted lanes fails with TokenRejected

New test file: tests/test_pe_lanes.py with 13 test methods covering:
- ALLOC_SHARED basic and multiple lanes
- Invalid parent handling
- Lane exhaustion per-frame and across frames
- FREE_LANE returning lane to pool
- Independent matching at same offset
- Independent matching at different offsets

tests/test_pe_lanes.py

···
+"""
+Lane-based PE rewrite tests.
+
+Verifies frame-lanes.AC3 and frame-lanes.AC8:
+- AC3.1: FrameOp.ALLOC_SHARED assigns next free lane from parent frame
+- AC3.2: FrameOp.FREE_LANE removes tag_store entry, clears lane data, keeps frame
+- AC3.3: FrameOp.FREE on shared frame returns lane if frame still in use
+- AC3.4: FrameOp.ALLOC unchanged — allocates fresh frame, assigns lane 0
+- AC3.5: FrameAllocated event gains lane field
+- AC3.6: ALLOC_SHARED with all lanes occupied emits TokenRejected
+- AC8.1: Two act_ids sharing a frame have independent matching
+- AC8.2: ALLOC_SHARED with exhausted lanes emits TokenRejected
+- AC8.3: FREE on shared frame preserves other lanes' data
+"""
+
+import pytest
+import simpy
+
+from cm_inst import (
+    ArithOp, FrameDest, FrameOp, Instruction, Port, TokenKind, OutputStyle,
+)
+from emu.events import (
+    FrameAllocated, FrameFreed, TokenReceived, TokenRejected, Matched, Emitted,
+)
+from emu.pe import ProcessingElement
+from emu.types import PEConfig
+from tokens import DyadToken, FrameControlToken
+
+
+def inject_and_run(env, pe, token):
+    """Helper: inject token and run simulation."""
+    def _put():
+        yield pe.input_store.put(token)
+    env.process(_put())
+    env.run()
+
+
+class TestAllocShared:
+    """AC3.1: ALLOC_SHARED assigns next free lane from parent frame."""
+
+    def test_alloc_shared_basic(self):
+        """Parent allocates frame, child allocates shared lane."""
+        env = simpy.Environment()
+        events = []
+        config = PEConfig(frame_count=4, lane_count=4, on_event=events.append)
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
+
+        # Parent ALLOC
+        fct_parent = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.ALLOC, payload=0
+        )
+        inject_and_run(env, pe, fct_parent)
+
+        parent_frame_id, parent_lane = pe.tag_store[0]
+        assert parent_lane == 0, "Parent should allocate lane 0"
+
+        # Child ALLOC_SHARED with parent_act_id=0
+        fct_child = FrameControlToken(
+            target=0, act_id=1, op=FrameOp.ALLOC_SHARED, payload=0
+        )
+        inject_and_run(env, pe, fct_child)
+
+        child_frame_id, child_lane = pe.tag_store[1]
+        assert child_frame_id == parent_frame_id, "Child should share parent's frame"
+        assert child_lane == 1, "Child should allocate lane 1"
+        assert child_lane != parent_lane, "Child lane should differ from parent"
+
+        # Verify FrameAllocated event for child
+        frame_allocated = [e for e in events if isinstance(e, FrameAllocated)]
+        assert len(frame_allocated) >= 2, "Should have 2 FrameAllocated events"
+        assert frame_allocated[0].lane == 0, "Parent allocated lane 0"
+        assert frame_allocated[1].lane == 1, "Child allocated lane 1"
+
+    def test_alloc_shared_multiple_lanes(self):
+        """Multiple children allocate different lanes from same parent frame."""
+        env = simpy.Environment()
+        events = []
+        config = PEConfig(frame_count=4, lane_count=4, on_event=events.append)
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
+
+        # Parent ALLOC
+        fct_parent = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.ALLOC, payload=0
+        )
+        inject_and_run(env, pe, fct_parent)
+        parent_frame_id, _parent_lane = pe.tag_store[0]
+
+        # Child 1 ALLOC_SHARED
+        fct_child1 = FrameControlToken(
+            target=0, act_id=1, op=FrameOp.ALLOC_SHARED, payload=0
+        )
+        inject_and_run(env, pe, fct_child1)
+        _child1_frame_id, child1_lane = pe.tag_store[1]
+
+        # Child 2 ALLOC_SHARED
+        fct_child2 = FrameControlToken(
+            target=0, act_id=2, op=FrameOp.ALLOC_SHARED, payload=0
+        )
+        inject_and_run(env, pe, fct_child2)
+        _child2_frame_id, child2_lane = pe.tag_store[2]
+
+        # All should share same frame
+        assert pe.tag_store[0][0] == parent_frame_id
+        assert pe.tag_store[1][0] == parent_frame_id
+        assert pe.tag_store[2][0] == parent_frame_id
+
+        # Lanes should differ: 0, 1, 2
+        assert child1_lane != 0, "Child1 lane should not be 0"
+        assert child2_lane != 0, "Child2 lane should not be 0"
+        assert child1_lane != child2_lane, "Child1 and child2 lanes should differ"
+
+    def test_alloc_shared_invalid_parent(self):
+        """ALLOC_SHARED with non-existent parent emits TokenRejected."""
+        env = simpy.Environment()
+        events = []
+        config = PEConfig(frame_count=4, lane_count=4, on_event=events.append)
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
+
+        # Try ALLOC_SHARED with non-existent parent_act_id=999
+        fct = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.ALLOC_SHARED, payload=999
+        )
+        inject_and_run(env, pe, fct)
+
+        rejected = [e for e in events if isinstance(e, TokenRejected)]
+        assert len(rejected) > 0, "Should have TokenRejected event"
+        assert "not in tag store" in rejected[0].reason, "Reason should mention tag_store"
+
+        # Parent should not be in tag_store
+        assert 999 not in pe.tag_store
+
+
+class TestLaneExhaustion:
+    """AC3.6, AC8.2: Lane exhaustion and TokenRejected."""
+
+    def test_alloc_shared_exhausts_all_lanes(self):
+        """Allocate all lanes, then ALLOC_SHARED fails with TokenRejected."""
+        env = simpy.Environment()
+        events = []
+        config = PEConfig(frame_count=4, lane_count=4, on_event=events.append)
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
+
+        # Parent ALLOC uses lane 0
+        fct_parent = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.ALLOC, payload=0
+        )
+        inject_and_run(env, pe, fct_parent)
+
+        # Allocate lanes 1, 2, 3
+        for i in range(1, 4):
+            fct = FrameControlToken(
+                target=0, act_id=i, op=FrameOp.ALLOC_SHARED, payload=0
+            )
+            inject_and_run(env, pe, fct)
+            assert i in pe.tag_store, f"Child {i} should be allocated"
+
+        # Try to allocate one more (all lanes exhausted)
+        fct_fail = FrameControlToken(
+            target=0, act_id=4, op=FrameOp.ALLOC_SHARED, payload=0
+        )
+        inject_and_run(env, pe, fct_fail)
+
+        rejected = [e for e in events if isinstance(e, TokenRejected)]
+        assert len(rejected) > 0, "Should have TokenRejected event"
+        assert "no free lanes" in rejected[0].reason, "Reason should be 'no free lanes'"
+
+        # act_id=4 should not be in tag_store
+        assert 4 not in pe.tag_store, "Failed allocation should not add to tag_store"
+
+    def test_lane_exhaustion_with_multiple_frames(self):
+        """Lane exhaustion is per-frame; different frames have independent lanes."""
+        env = simpy.Environment()
+        events = []
+        config = PEConfig(frame_count=4, lane_count=4, on_event=events.append)
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
+
+        # Frame 1: Parent 0 allocates lane 0
+        fct1 = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.ALLOC, payload=0
+        )
+        inject_and_run(env, pe, fct1)
+        frame1_id, _lane = pe.tag_store[0]
+
+        # Frame 2: Parent 10 allocates lane 0
+        fct2 = FrameControlToken(
+            target=0, act_id=10, op=FrameOp.ALLOC, payload=0
+        )
+        inject_and_run(env, pe, fct2)
+        frame2_id, _lane = pe.tag_store[10]
+
+        assert frame1_id != frame2_id, "Should allocate different frames"
+
+        # Frame 1: Exhaust all lanes
+        for i in range(1, 4):
+            fct = FrameControlToken(
+                target=0, act_id=i, op=FrameOp.ALLOC_SHARED, payload=0
+            )
+            inject_and_run(env, pe, fct)
+
+        # Frame 2: Can still allocate more lanes (independent)
+        for i in range(11, 14):
+            fct = FrameControlToken(
+                target=0, act_id=i, op=FrameOp.ALLOC_SHARED, payload=10
+            )
+            inject_and_run(env, pe, fct)
+            assert i in pe.tag_store, f"Frame2 child {i} should be allocated"
+
+
+class TestFreeLane:
+    """AC3.2: FREE_LANE clears lane data, keeps frame, returns lane to pool."""
+
+    def test_free_lane_basic(self):
+        """FREE_LANE removes act_id from tag_store, clears lane data, keeps frame."""
+        env = simpy.Environment()
+        events = []
+        config = PEConfig(frame_count=4, lane_count=4, on_event=events.append)
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
+
+        # Parent ALLOC
+        fct_parent = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.ALLOC, payload=0
+        )
+        inject_and_run(env, pe, fct_parent)
+        parent_frame_id, _parent_lane = pe.tag_store[0]
+
+        # Child ALLOC_SHARED
+        fct_child = FrameControlToken(
+            target=0, act_id=1, op=FrameOp.ALLOC_SHARED, payload=0
+        )
+        inject_and_run(env, pe, fct_child)
+        _child_frame_id, child_lane = pe.tag_store[1]
+
+        # FREE_LANE for child
+        fct_free = FrameControlToken(
+            target=0, act_id=1, op=FrameOp.FREE_LANE, payload=0
+        )
+        inject_and_run(env, pe, fct_free)
+
+        # Child should be removed from tag_store
+        assert 1 not in pe.tag_store, "Child should be removed from tag_store"
+
+        # Parent should still be present
+        assert 0 in pe.tag_store, "Parent should still be in tag_store"
+
+        # Frame should NOT be in free_frames (still used by parent)
+        assert parent_frame_id not in pe.free_frames, "Frame should not be free"
+
+        # FrameFreed event should have frame_freed=False
+        frame_freed = [e for e in events if isinstance(e, FrameFreed)]
+        assert len(frame_freed) > 0, "Should have FrameFreed event"
+        assert frame_freed[-1].frame_freed == False, "frame_freed should be False"
+        assert frame_freed[-1].lane == child_lane, "Event should report correct lane"
+
+    def test_free_lane_returns_lane_to_pool(self):
+        """After FREE_LANE, freed lane can be reused by ALLOC_SHARED."""
+        env = simpy.Environment()
+        events = []
+        config = PEConfig(frame_count=4, lane_count=4, on_event=events.append)
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
+
+        # Parent ALLOC
+        fct_parent = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.ALLOC, payload=0
+        )
+        inject_and_run(env, pe, fct_parent)
+        parent_frame_id, _parent_lane = pe.tag_store[0]
+
+        # Child 1 ALLOC_SHARED (lane 1)
+        fct_child1 = FrameControlToken(
+            target=0, act_id=1, op=FrameOp.ALLOC_SHARED, payload=0
+        )
+        inject_and_run(env, pe, fct_child1)
+        _child1_frame_id, child1_lane = pe.tag_store[1]
+        assert child1_lane == 1
+
+        # FREE_LANE child 1
+        fct_free = FrameControlToken(
+            target=0, act_id=1, op=FrameOp.FREE_LANE, payload=0
+        )
+        inject_and_run(env, pe, fct_free)
+
+        # Child 2 ALLOC_SHARED (should get lane 1 again)
+        fct_child2 = FrameControlToken(
+            target=0, act_id=2, op=FrameOp.ALLOC_SHARED, payload=0
+        )
+        inject_and_run(env, pe, fct_child2)
+        _child2_frame_id, child2_lane = pe.tag_store[2]
+
+        # Lane 1 should be reused for child 2
+        assert child2_lane == 1, "Freed lane 1 should be reused"
+
+
+class TestIndependentMatching:
+    """AC8.1: Two act_ids sharing a frame have independent matching."""
+
+    def test_independent_matching_same_offset(self):
+        """L operand for act_id 0 does not interfere with L for act_id 1."""
+        env = simpy.Environment()
+        events = []
+        config = PEConfig(
+            frame_count=4, lane_count=4, matchable_offsets=4, on_event=events.append
+        )
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
+
+        # Parent ALLOC
+        fct_parent = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.ALLOC, payload=0
+        )
+        inject_and_run(env, pe, fct_parent)
+        parent_frame_id, _parent_lane = pe.tag_store[0]
+
+        # Child ALLOC_SHARED
+        fct_child = FrameControlToken(
+            target=0, act_id=1, op=FrameOp.ALLOC_SHARED, payload=0
+        )
+        inject_and_run(env, pe, fct_child)
+        _child_frame_id, child_lane = pe.tag_store[1]
+
+        # Install dyadic instruction at offset 0
+        inst = Instruction(
+            opcode=ArithOp.ADD,
+            output=OutputStyle.SINK,
+            has_const=False,
+            dest_count=0,
+            wide=False,
+            fref=0,
+        )
+        pe.iram[0] = inst
+
+        # Send L operand for act_id=0
+        tok_l_0 = DyadToken(
+            target=0, offset=0, act_id=0, data=5, port=Port.L
+        )
+        inject_and_run(env, pe, tok_l_0)
+
+        # Should have 1 TokenReceived, 0 Matched (waiting for R)
+        matched = [e for e in events if isinstance(e, Matched)]
+        assert len(matched) == 0, "Should not match yet (waiting for R)"
+
+        # Send L operand for act_id=1 at same offset
+        tok_l_1 = DyadToken(
+            target=0, offset=0, act_id=1, data=7, port=Port.L
+        )
+        inject_and_run(env, pe, tok_l_1)
+
+        # Should still have 0 Matched (both waiting for R)
+        matched = [e for e in events if isinstance(e, Matched)]
+        assert len(matched) == 0, "Both should be waiting for R"
+
+        # Send R for act_id=0
+        tok_r_0 = DyadToken(
+            target=0, offset=0, act_id=0, data=3, port=Port.R
+        )
+        inject_and_run(env, pe, tok_r_0)
+
+        # Should now have 1 Matched for act_id=0
+        matched = [e for e in events if isinstance(e, Matched)]
+        assert len(matched) == 1, "Should have 1 match for act_id=0"
+        assert matched[0].act_id == 0, "Match should be for act_id=0"
+        assert matched[0].left == 5, "Left should be 5"
+        assert matched[0].right == 3, "Right should be 3"
+
+        # Send R for act_id=1
+        tok_r_1 = DyadToken(
+            target=0, offset=0, act_id=1, data=2, port=Port.R
+        )
+        inject_and_run(env, pe, tok_r_1)
+
+        # Should now have 2 Matched
+        matched = [e for e in events if isinstance(e, Matched)]
+        assert len(matched) == 2, "Should have 2 matches total"
+        m1 = [m for m in matched if m.act_id == 1][0]
+        assert m1.left == 7, "act_id=1 left should be 7"
+        assert m1.right == 2, "act_id=1 right should be 2"
+
+    def test_independent_matching_different_offsets(self):
+        """Different offsets per lane maintain independence."""
+        env = simpy.Environment()
+        events = []
+        config = PEConfig(
+            frame_count=4, lane_count=4, matchable_offsets=4, on_event=events.append
+        )
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
+
+        # Parent ALLOC
+        fct_parent = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.ALLOC, payload=0
+        )
+        inject_and_run(env, pe, fct_parent)
+
+        # Child ALLOC_SHARED
+        fct_child = FrameControlToken(
+            target=0, act_id=1, op=FrameOp.ALLOC_SHARED, payload=0
+        )
+        inject_and_run(env, pe, fct_child)
+
+        # Install dyadic instructions at offsets 0 and 1
+        inst0 = Instruction(
+            opcode=ArithOp.ADD, output=OutputStyle.SINK,
+            has_const=False, dest_count=0, wide=False, fref=0
+        )
+        inst1 = Instruction(
+            opcode=ArithOp.SUB, output=OutputStyle.SINK,
+            has_const=False, dest_count=0, wide=False, fref=0
+        )
+        pe.iram[0] = inst0
+        pe.iram[1] = inst1
+
+        # Send L for act_id=0 at offset 0
+        tok_l_0_off0 = DyadToken(
+            target=0, offset=0, act_id=0, data=10, port=Port.L
+        )
+        inject_and_run(env, pe, tok_l_0_off0)
+
+        # Send L for act_id=1 at offset 1
+        tok_l_1_off1 = DyadToken(
+            target=0, offset=1, act_id=1, data=20, port=Port.L
+        )
+        inject_and_run(env, pe, tok_l_1_off1)
+
+        # Neither should match yet
+        matched = [e for e in events if isinstance(e, Matched)]
+        assert len(matched) == 0, "No matches yet"
+
+        # Send R for act_id=0 at offset 0
+        tok_r_0_off0 = DyadToken(
+            target=0, offset=0, act_id=0, data=5, port=Port.R
+        )
+        inject_and_run(env, pe, tok_r_0_off0)
+
+        # Should match for offset 0
+        matched = [e for e in events if isinstance(e, Matched)]
+        assert len(matched) == 1, "Should have 1 match"
+        assert matched[0].offset == 0, "Match should be at offset 0"
+
+        # Send R for act_id=1 at offset 1
+        tok_r_1_off1 = DyadToken(
+            target=0, offset=1, act_id=1, data=15, port=Port.R
+        )
+        inject_and_run(env, pe, tok_r_1_off1)
+
+        # Should match for offset 1
+        matched = [e for e in events if isinstance(e, Matched)]
+        assert len(matched) == 2, "Should have 2 matches"
+        m1 = [m for m in matched if m.offset == 1][0]
+        assert m1.act_id == 1, "Offset 1 match should be act_id=1"
+
+
+class TestSmartFree:
+    """AC3.3, AC8.3: Smart FREE on shared frames preserves data and manages lanes."""
+
+    def test_free_on_shared_frame_preserves_other_lanes(self):
+        """FREE on act_id=0 when act_id=1 uses frame; lane 1 data preserved."""
+        env = simpy.Environment()
+        events = []
+        config = PEConfig(
+            frame_count=4, lane_count=4, matchable_offsets=4, on_event=events.append
+        )
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
+
+        # Parent ALLOC
+        fct_parent = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.ALLOC, payload=0
+        )
+        inject_and_run(env, pe, fct_parent)
+        parent_frame_id, _parent_lane = pe.tag_store[0]
+
+        # Child ALLOC_SHARED
+        fct_child = FrameControlToken(
+            target=0, act_id=1, op=FrameOp.ALLOC_SHARED, payload=0
+        )
+        inject_and_run(env, pe, fct_child)
+        _child_frame_id, child_lane = pe.tag_store[1]
+
+        # Install instruction
+        inst = Instruction(
+            opcode=ArithOp.ADD, output=OutputStyle.SINK,
+            has_const=False, dest_count=0, wide=False, fref=0
+        )
+        pe.iram[0] = inst
+
+        # Store L operand on child's lane
+        tok_l_1 = DyadToken(
+            target=0, offset=0, act_id=1, data=7, port=Port.L
+        )
+        inject_and_run(env, pe, tok_l_1)
+
+        # Verify child's match slot has data
+        frame_id, lane = pe.tag_store[1]
+        assert pe.match_data[frame_id][0][lane] == 7, "Child lane should have L operand"
+        assert pe.presence[frame_id][0][lane] == True, "Child presence should be set"
+
+        # FREE parent
+        fct_free_parent = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.FREE, payload=0
+        )
+        inject_and_run(env, pe, fct_free_parent)
+
+        # Parent should be removed, child should still be present
+        assert 0 not in pe.tag_store, "Parent should be removed"
+        assert 1 in pe.tag_store, "Child should still be present"
+
+        # Frame should NOT be in free_frames
+        assert parent_frame_id not in pe.free_frames, "Frame should not be free"
+
+        # Child's match data should be preserved
+        assert pe.match_data[frame_id][0][lane] == 7, "Child data should be preserved"
+        assert pe.presence[frame_id][0][lane] == True, "Child presence should be preserved"
+
+        # FrameFreed event should have frame_freed=False
+        frame_freed = [e for e in events if isinstance(e, FrameFreed)]
+        assert any(e.frame_freed == False for e in frame_freed), "Should have frame_freed=False"
+
+    def test_free_last_lane_returns_frame(self):
+        """FREE on last act_id using frame returns frame to free_frames."""
+        env = simpy.Environment()
+        events = []
+        config = PEConfig(frame_count=4, lane_count=4, on_event=events.append)
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
+
+        # Parent ALLOC
+        fct_parent = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.ALLOC, payload=0
+        )
+        inject_and_run(env, pe, fct_parent)
+        parent_frame_id, _parent_lane = pe.tag_store[0]
+
+        # Child ALLOC_SHARED
+        fct_child = FrameControlToken(
+            target=0, act_id=1, op=FrameOp.ALLOC_SHARED, payload=0
+        )
+        inject_and_run(env, pe, fct_child)
+
+        # FREE child
+        fct_free_child = FrameControlToken(
+            target=0, act_id=1, op=FrameOp.FREE_LANE, payload=0
+        )
+        inject_and_run(env, pe, fct_free_child)
+
+        # Frame should still not be free (parent still using it)
+        assert parent_frame_id not in pe.free_frames, "Frame should not be free yet"
+
+        # FREE parent
+        fct_free_parent = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.FREE, payload=0
+        )
+        inject_and_run(env, pe, fct_free_parent)
+
+        # Now frame should be free
+        assert parent_frame_id in pe.free_frames, "Frame should be free"
+
+        # tag_store should be empty
+        assert len(pe.tag_store) == 0, "tag_store should be empty"
+
+        # lane_free entry should be cleaned up
+        assert parent_frame_id not in pe.lane_free, "lane_free entry should be cleaned"
+
+        # FrameFreed event should have frame_freed=True
+        frame_freed = [e for e in events if isinstance(e, FrameFreed)]
+        assert any(e.frame_freed == True for e in frame_freed), "Should have frame_freed=True"
+
+    def test_alloc_unchanged_allocates_fresh_frame(self):
+        """Regular ALLOC still works: allocates fresh frame, lane 0."""
+        env = simpy.Environment()
+        events = []
+        config = PEConfig(frame_count=4, lane_count=4, on_event=events.append)
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
+
+        # First ALLOC
+        fct1 = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.ALLOC, payload=0
+        )
+        inject_and_run(env, pe, fct1)
+        frame_id_0, lane_0 = pe.tag_store[0]
+        assert lane_0 == 0, "First ALLOC should assign lane 0"
+
+        # Second ALLOC (different frame)
+        fct2 = FrameControlToken(
+            target=0, act_id=10, op=FrameOp.ALLOC, payload=0
+        )
+        inject_and_run(env, pe, fct2)
+        frame_id_10, lane_10 = pe.tag_store[10]
+        assert lane_10 == 0, "Second ALLOC should assign lane 0"
+
+        # Frames should be different
+        assert frame_id_0 != frame_id_10, "Different ALLOC should get different frames"
+
+    def test_data_preservation_across_free_lanes(self):
+        """Match data on one lane not affected by FREE of another lane."""
+        env = simpy.Environment()
+        events = []
+        config = PEConfig(
+            frame_count=4, lane_count=4, matchable_offsets=4, on_event=events.append
+        )
+        pe = ProcessingElement(env=env, pe_id=0, config=config)
+
+        # Parent ALLOC
+        fct_parent = FrameControlToken(
+            target=0, act_id=0, op=FrameOp.ALLOC, payload=0
+        )
+        inject_and_run(env, pe, fct_parent)
+        frame_id, _parent_lane = pe.tag_store[0]
+
+        # Child 1 ALLOC_SHARED
+        fct_child1 = FrameControlToken(
+            target=0, act_id=1, op=FrameOp.ALLOC_SHARED, payload=0
+        )
+        inject_and_run(env, pe, fct_child1)
+        _frame_id_1, lane_1 = pe.tag_store[1]
+
+        # Child 2 ALLOC_SHARED
+        fct_child2 = FrameControlToken(
+            target=0, act_id=2, op=FrameOp.ALLOC_SHARED, payload=0
+        )
+        inject_and_run(env, pe, fct_child2)
+        _frame_id_2, lane_2 = pe.tag_store[2]
+
+        # Install instruction
+        inst = Instruction(
+            opcode=ArithOp.ADD, output=OutputStyle.SINK,
+            has_const=False, dest_count=0, wide=False, fref=0
+        )
+        pe.iram[0] = inst
+
+        # Store L operand on lane 1
+        tok_l_1 = DyadToken(
+            target=0, offset=0, act_id=1, data=7, port=Port.L
+        )
+        inject_and_run(env, pe, tok_l_1)
+
+        # Store L operand on lane 2
+        tok_l_2 = DyadToken(
+            target=0, offset=0, act_id=2, data=11, port=Port.L
+        )
+        inject_and_run(env, pe, tok_l_2)
+
+        # FREE lane 1
+        fct_free_1 = FrameControlToken(
+            target=0, act_id=1, op=FrameOp.FREE_LANE, payload=0
+        )
+        inject_and_run(env, pe, fct_free_1)
+
+        # Lane 2's data should be untouched
+        assert pe.match_data[frame_id][0][lane_2] == 11, "Lane 2 data should be preserved"
+        assert pe.presence[frame_id][0][lane_2] == True, "Lane 2 presence should be preserved"
+
+        # Lane 1 should be cleared
+        assert pe.match_data[frame_id][0][lane_1] is None, "Lane 1 data should be cleared"
+        assert pe.presence[frame_id][0][lane_1] == False, "Lane 1 presence should be cleared"