sim._pycoro: coalesce delta cycles after assignments.

Before this commit, each `Assign()` yielded by the testbench coroutine
iterated the design to fixed point. This is inefficient, and moreover
interferes with effective visualization of delta cycles.

After this commit, a yielded `Assign()` flags the coroutine stack frame
as having mutated state, and iterates the design to fixed point before
explicitly waiting or reading state.

Author: whitequark

amaranth/sim/_pycoro.py

@@ -32,6 +32,7 @@ def reset(self):
             **_ValueCompiler.helpers
         }
         self.waits_on = SignalSet()
+        self.command = None
 
     def src_loc(self):
         coroutine = self.coroutine
@@ -58,29 +59,38 @@ def run(self):
         if self.coroutine is None:
             return
 
-        self.clear_triggers()
+        if self.command is None:
+            self.clear_triggers()
 
         response = None
         exception = None
+        assigned = False
         while True:
-            try:
-                if exception is None:
-                    command = self.coroutine.send(response)
-                else:
-                    command = self.coroutine.throw(exception)
-            except StopIteration:
-                self.passive = True
-                self.coroutine = None
-                return False # no assignment
+            if self.command is not None:
+                command, self.command = self.command, None
+            else:
+                try:
+                    if exception is None:
+                        command = self.coroutine.send(response)
+                    else:
+                        command = self.coroutine.throw(exception)
+                except StopIteration:
+                    self.passive = True
+                    self.coroutine = None
+                    return assigned
 
             try:
                 if command is None:
                     command = self.default_cmd
+                if isinstance(command, ValueCastable):
+                    command = Value.cast(command)
                 response = None
                 exception = None
 
-                if isinstance(command, ValueCastable):
-                    command = Value.cast(command)
+                if assigned and isinstance(command, (Value, Tick, Settle, Delay, MemorySimRead)):
+                    self.command = command
+                    return True # changed state; run RTL processes and retry
+
                 if isinstance(command, Value):
                     exec(_RHSValueCompiler.compile(self.state, command, mode="curr"),
                         self.exec_locals)
@@ -90,7 +100,7 @@ def run(self):
                     exec(_StatementCompiler.compile(self.state, command),
                         self.exec_locals)
                     if isinstance(command, Assign) and self.testbench:
-                        return True # assignment; run a delta cycle
+                        assigned = True
 
                 elif type(command) is Tick:
                     domain = command.domain
@@ -105,17 +115,17 @@ def run(self):
                     self.add_trigger(domain.clk, trigger=1 if domain.clk_edge == "pos" else 0)
                     if domain.rst is not None and domain.async_reset:
                         self.add_trigger(domain.rst, trigger=1)
-                    return False # no assignments
+                    return False # did not change state
 
                 elif type(command) is Settle:
                     self.state.wait_interval(self, None)
-                    return False # no assignments
+                    return False # did not change state
 
                 elif type(command) is Delay:
                     # Internal timeline is in 1ps integeral units, intervals are public API and in floating point
                     interval = int(command.interval * 1e12) if command.interval is not None else None
                     self.state.wait_interval(self, interval)
-                    return False # no assignments
+                    return False # did not change state
 
                 elif type(command) is Passive:
                     self.passive = True
@@ -144,7 +154,7 @@ def run(self):
                     assert isinstance(state, BaseMemoryState)
                     state.write(addr, data)
                     if self.testbench:
-                        return True # assignment; run a delta cycle
+                        assigned = True
 
                 elif command is None: # only possible if self.default_cmd is None
                     raise TypeError("Received default command from process {!r} that was added "