Rework clock usage in the event loop

Author: fjarri

src/trio/_abc.py

@@ -43,7 +43,7 @@ def current_time(self) -> float:
         """
 
     @abstractmethod
-    def deadline_to_sleep_time(self, deadline: float) -> float:
+    def deadline_to_sleep_time(self, timeout: float) -> float:
         """Compute the real time until the given deadline.
 
         This is called before we enter a system-specific wait function like
@@ -66,14 +66,8 @@ def deadline_to_sleep_time(self, deadline: float) -> float:
 
         """
 
-    @property
-    def autojump_threshold(self) -> float:
-        return inf
-
-    def autojump(self) -> None:
-        # If `autojump_threshold()` has the default implementation (returning `inf`),
-        # this will never be called.
-        raise NotImplementedError
+    def propagate(self, real_time_passed: float, virtual_timeout: float) -> None:
+        pass
 
 
 class Instrument(ABC):  # noqa: B024  # conceptually is ABC

src/trio/_core/_mock_clock.py

@@ -113,13 +113,11 @@ def _try_resync_autojump_threshold(self) -> None:
         except AttributeError:
             pass
 
-    # Invoked by the run loop when runner.clock_autojump_threshold is
-    # exceeded.
-    def autojump(self) -> None:
-        statistics = _core.current_statistics()
-        jump = statistics.seconds_to_next_deadline
-        if 0 < jump < inf:
-            self.jump(jump)
+    def propagate(self, real_time_passed: float, virtual_timeout: float) -> None:
+        if self._rate > 0:
+            self.jump(real_time_passed * self._rate)
+        else:
+            self.jump(virtual_timeout)
 
     def _real_to_virtual(self, real: float) -> float:
         real_offset = real - self._real_base
@@ -132,14 +130,20 @@ def start_clock(self) -> None:
     def current_time(self) -> float:
         return self._real_to_virtual(self._real_clock())
 
-    def deadline_to_sleep_time(self, deadline: float) -> float:
-        virtual_timeout = deadline - self.current_time()
-        if virtual_timeout <= 0:
-            return 0
-        elif self._rate > 0:
-            return virtual_timeout / self._rate
-        else:
-            return 999999999
+    def deadline_to_sleep_time(self, timeout: float) -> float:
+        virtual_timeout = max(0.0, timeout)
+
+        real_timeout = virtual_timeout
+
+        if self._rate > 0:
+            real_timeout /= self._rate
+        elif real_timeout > 0 and self._rate == 0:
+            real_timeout = 999999999.0
+
+        if real_timeout > self.autojump_threshold:
+            real_timeout = self.autojump_threshold
+
+        return real_timeout
 
     def jump(self, seconds: float) -> None:
         """Manually advance the clock by the given number of seconds.

src/trio/_core/_run.py

@@ -204,8 +204,8 @@ def start_clock(self) -> None:
     def current_time(self) -> float:
         return self.offset + perf_counter()
 
-    def deadline_to_sleep_time(self, deadline: float) -> float:
-        return deadline - self.current_time()
+    def deadline_to_sleep_time(self, timeout: float) -> float:
+        return timeout
 
 
 class IdlePrimedTypes(enum.Enum):
@@ -2739,36 +2739,38 @@ def unrolled_run(
         # You know how people talk about "event loops"? This 'while' loop right
         # here is our event loop:
         while runner.tasks:
+            now = runner.clock.current_time()
+
             if runner.runq:
-                timeout: float = 0
+                virtual_timeout: float = 0
             else:
                 deadline = runner.deadlines.next_deadline()
-                timeout = runner.clock.deadline_to_sleep_time(deadline)
-            timeout = min(max(0, timeout), _MAX_TIMEOUT)
+                virtual_timeout = max(0, deadline - now)
 
             idle_primed = None
             if runner.waiting_for_idle:
                 cushion, _ = runner.waiting_for_idle.keys()[0]
-                if cushion < timeout:
-                    timeout = cushion
+                if cushion < virtual_timeout:
+                    virtual_timeout = cushion
                     idle_primed = IdlePrimedTypes.WAITING_FOR_IDLE
-            # We use 'elif' here because if there are tasks in
-            # wait_all_tasks_blocked, then those tasks will wake up without
-            # jumping the clock, so we don't need to autojump.
-            elif runner.clock.autojump_threshold < timeout:
-                timeout = runner.clock.autojump_threshold
-                idle_primed = IdlePrimedTypes.AUTOJUMP_CLOCK
+
+            virtual_timeout = min(max(0, virtual_timeout), _MAX_TIMEOUT)
+            real_timeout = runner.clock.deadline_to_sleep_time(virtual_timeout)
 
             if "before_io_wait" in runner.instruments:
-                runner.instruments.call("before_io_wait", timeout)
+                runner.instruments.call("before_io_wait", real_timeout)
 
             # Driver will call io_manager.get_events(timeout) and pass it back
             # in through the yield
-            events = yield timeout
+            events = yield real_timeout
+
+            new_now = runner.clock.current_time()
+            runner.clock.propagate(new_now - now, virtual_timeout)
+
             runner.io_manager.process_events(events)
 
             if "after_io_wait" in runner.instruments:
-                runner.instruments.call("after_io_wait", timeout)
+                runner.instruments.call("after_io_wait", real_timeout)
 
             # Process cancellations due to deadline expiry
             now = runner.clock.current_time()
@@ -2805,9 +2807,6 @@ def unrolled_run(
                             runner.reschedule(task)
                         else:
                             break
-                else:
-                    assert idle_primed is IdlePrimedTypes.AUTOJUMP_CLOCK
-                    runner.clock.autojump()
 
             # Process all runnable tasks, but only the ones that are already
             # runnable now. Anything that becomes runnable during this cycle

src/trio/_core/_tests/test_guest_mode.py

@@ -187,13 +187,6 @@ def current_time(self) -> float:
         def deadline_to_sleep_time(self, deadline: float) -> float:
             raise NotImplementedError()
 
-        @property
-        def autojump_threshold(self) -> float:
-            raise NotImplementedError()
-
-        def autojump(self) -> None:
-            raise NotImplementedError()
-
     def after_start_never_runs() -> None:  # pragma: no cover
         pytest.fail("shouldn't get here")
 

src/trio/_core/_tests/test_mock_clock.py

@@ -24,9 +24,9 @@ def test_mock_clock() -> None:
     with pytest.raises(ValueError, match=r"^time can't go backwards$"):
         c.jump(-1)
     assert c.current_time() == 1.2
-    assert c.deadline_to_sleep_time(1.1) == 0
-    assert c.deadline_to_sleep_time(1.2) == 0
-    assert c.deadline_to_sleep_time(1.3) > 999999
+    assert c.deadline_to_sleep_time(-0.1) == 0
+    assert c.deadline_to_sleep_time(0.0) == 0
+    assert c.deadline_to_sleep_time(0.1) == 999999999
 
     with pytest.raises(ValueError, match=r"^rate must be >= 0$"):
         c.rate = -1
@@ -36,15 +36,15 @@ def test_mock_clock() -> None:
     assert c.current_time() == 1.2
     REAL_NOW += 1
     assert c.current_time() == 3.2
-    assert c.deadline_to_sleep_time(3.1) == 0
-    assert c.deadline_to_sleep_time(3.2) == 0
-    assert c.deadline_to_sleep_time(4.2) == 0.5
+    assert c.deadline_to_sleep_time(-0.1) == 0
+    assert c.deadline_to_sleep_time(0.0) == 0
+    assert c.deadline_to_sleep_time(1.0) == 0.5
 
     c.rate = 0.5
     assert c.current_time() == 3.2
-    assert c.deadline_to_sleep_time(3.1) == 0
-    assert c.deadline_to_sleep_time(3.2) == 0
-    assert c.deadline_to_sleep_time(4.2) == 2.0
+    assert c.deadline_to_sleep_time(-0.1) == 0
+    assert c.deadline_to_sleep_time(0.0) == 0
+    assert c.deadline_to_sleep_time(1.0) == 2.0
 
     c.jump(0.8)
     assert c.current_time() == 4.0
@@ -80,11 +80,12 @@ async def test_mock_clock_autojump(mock_clock: MockClock) -> None:
     t = _core.current_time()
     # this should wake up before the autojump threshold triggers, so time
     # shouldn't change
+    # TODO: technically, this waits for an infinite virtual time - how should `current_time()` change?
     await wait_all_tasks_blocked()
     assert t == _core.current_time()
     # this should too
     await wait_all_tasks_blocked(0.01)
-    assert t == _core.current_time()
+    assert t + 0.01 == _core.current_time()
 
     # set up a situation where the autojump task is blocked for a long long
     # time, to make sure that cancel-and-adjust-threshold logic is working
@@ -179,15 +180,16 @@ async def waiter() -> None:
 
 
 async def test_initialization_doesnt_mutate_runner() -> None:
+    # TODO: is this test even necessary now?
     before = (
         GLOBAL_RUN_CONTEXT.runner.clock,
-        GLOBAL_RUN_CONTEXT.runner.clock.autojump_threshold,
+        # GLOBAL_RUN_CONTEXT.runner.clock.autojump_threshold,
     )
 
     MockClock(autojump_threshold=2, rate=3)
 
     after = (
         GLOBAL_RUN_CONTEXT.runner.clock,
-        GLOBAL_RUN_CONTEXT.runner.clock.autojump_threshold,
+        # GLOBAL_RUN_CONTEXT.runner.clock.autojump_threshold,
     )
     assert before == after