Claude channels/timers review

lib/runtime/src/platform/linux_x86_64/runtime.rs

@@ -206,25 +206,47 @@ where
 {
     let owner = current_thread_ptr();
     let id = allocate_timer_id();
-    let deadline = deadline_from_now(delay);
+
     #[cfg(debug_assertions)]
     tracing::trace!(
         target: trace_targets::TIMER,
         event = "set_interval",
         timer_id = id,
         delay_ns = delay.as_nanos() as u64,
-        deadline_ns = deadline.as_nanos() as u64,
         "scheduling interval"
     );
-    let timer = TimerNode::interval(
-        id,
-        deadline,
-        delay,
-        Rc::new(RefCell::new(Box::new(callback))),
-    );
 
-    current_thread().timers.borrow_mut().insert(timer);
-    rearm_thread_timer();
+    if delay.is_zero() {
+        // Zero-delay intervals never touch the timer heap or arm an io_uring
+        // timer (a past-deadline kernel timer would fire on every event loop
+        // iteration, spinning the runtime at 100 % CPU).  Instead the callback
+        // is stored in `immediate_intervals` and self-schedules as a macrotask
+        // each turn, mirroring JS `setInterval(f, 0)` semantics.
+        let callback = Rc::new(RefCell::new(Box::new(callback) as Box<dyn FnMut()>));
+        current_thread()
+            .immediate_intervals
+            .borrow_mut()
+            .insert(id, Rc::clone(&callback));
+        schedule_immediate_interval(owner, id);
+    } else {
+        let deadline = deadline_from_now(delay);
+        #[cfg(debug_assertions)]
+        tracing::trace!(
+            target: trace_targets::TIMER,
+            event = "set_interval_deadline",
+            timer_id = id,
+            deadline_ns = deadline.as_nanos() as u64,
+            "interval deadline computed"
+        );
+        let timer = TimerNode::interval(
+            id,
+            deadline,
+            delay,
+            Rc::new(RefCell::new(Box::new(callback))),
+        );
+        current_thread().timers.borrow_mut().insert(timer);
+        rearm_thread_timer();
+    }
 
     IntervalHandle {
         id,
@@ -556,6 +578,9 @@ struct ThreadState {
     local_microtasks: RefCell<VecDeque<LocalTask>>,
     local_macrotasks: RefCell<VecDeque<MacroTask>>,
     timers: RefCell<TimerHeap>,
+    /// Zero-delay intervals bypasses the timer heap entirely. Each entry
+    /// re-enqueues itself as a macrotask on every turn.
+    immediate_intervals: RefCell<HashMap<usize, Rc<RefCell<Box<dyn FnMut()>>>>>,
     next_timer_id: Cell<usize>,
     children: RefCell<Vec<ChildWorker>>,
 }
@@ -573,6 +598,7 @@ impl ThreadState {
             local_microtasks: RefCell::new(VecDeque::new()),
             local_macrotasks: RefCell::new(VecDeque::new()),
             timers: RefCell::new(TimerHeap::new()),
+            immediate_intervals: RefCell::new(HashMap::new()),
             next_timer_id: Cell::new(1),
             children: RefCell::new(Vec::new()),
         }
@@ -1109,7 +1135,8 @@ fn has_ready_work() -> bool {
 }
 
 fn has_pending_timers() -> bool {
-    !current_thread().timers.borrow().is_empty()
+    let state = current_thread();
+    !state.timers.borrow().is_empty() || !state.immediate_intervals.borrow().is_empty()
 }
 
 fn allocate_timer_id() -> usize {
@@ -1126,11 +1153,37 @@ fn clear_timer(owner: *const ThreadState, id: usize) {
         "timer handles must be cleared on their originating thread"
     );
 
-    if current_thread().timers.borrow_mut().remove(id).is_some() {
+    let state = current_thread();
+    if state.timers.borrow_mut().remove(id).is_some() {
         rearm_thread_timer();
+    } else {
+        // May be a zero-delay immediate interval; removal is a no-op if absent.
+        state.immediate_intervals.borrow_mut().remove(&id);
     }
 }
 
+/// Enqueues one macrotask turn for a zero-delay interval.
+///
+/// The macrotask checks whether the interval is still live (not cleared), fires
+/// the callback, and re-enqueues itself for the next turn.
+fn schedule_immediate_interval(owner: *const ThreadState, id: usize) {
+    push_local_macrotask(Box::new(move || {
+        let callback = current_thread()
+            .immediate_intervals
+            .borrow()
+            .get(&id)
+            .map(Rc::clone);
+        let Some(callback) = callback else {
+            return; // interval was cleared before this turn ran
+        };
+        (callback.borrow_mut())();
+        // Re-enqueue for the next turn if still live.
+        if current_thread().immediate_intervals.borrow().contains_key(&id) {
+            schedule_immediate_interval(owner, id);
+        }
+    }));
+}
+
 fn dispatch_expired_timers() {
     let now = deadline_from_now(Duration::ZERO);
     let due = current_thread().timers.borrow_mut().pop_due(now);
@@ -1333,4 +1386,30 @@ mod tests {
 
         assert_eq!(*observed.lock().unwrap(), Some(7));
     }
+
+    #[test]
+    fn zero_interval_fires_once_per_turn_without_spinning() {
+        // set_interval(Duration::ZERO, ..) must not busy-spin the event loop.
+        // Each tick is one macrotask turn; we verify the count advances across
+        // turns by awaiting a sleep between checks.
+        let count = Rc::new(Cell::new(0usize));
+        let count_clone = Rc::clone(&count);
+        let handle_slot: Rc<RefCell<Option<super::IntervalHandle>>> =
+            Rc::new(RefCell::new(None));
+        let handle_slot_clone = Rc::clone(&handle_slot);
+
+        let handle = set_interval(Duration::ZERO, move || {
+            let next = count_clone.get() + 1;
+            count_clone.set(next);
+            if next == 5 {
+                let handle = handle_slot_clone.borrow_mut().take().unwrap();
+                clear_interval(&handle);
+            }
+        });
+        *handle_slot.borrow_mut() = Some(handle);
+
+        run();
+
+        assert_eq!(count.get(), 5);
+    }
 }