cap catch-up tick iters in skip_and_tick to prevent queue starvation

ZeWaka · ZeWaka · commit 9fb19b541004 · 2026-05-06T23:16:36.000+01:00
When the timer thread is suspended for a long time skip_and_tick could loop for tons of iters.
We instead cap it so it stays more responsive.
The run() loop re-enters immediately and continues catching
up on subsequent iterations, so no timer accuracy is permanently lost.
diff --git a/src/timer.rs b/src/timer.rs
@@ -440,6 +440,9 @@ where
         }
     }
 
+    /// Maximum number of catch-up ticks processed in a single `skip_and_tick` call.
+    const MAX_CATCH_UP_TICKS: u128 = 1_000;
+
     #[inline(always)]
     fn skip_and_tick(&mut self, can_skip: u32, elapsed: u128) {
         let can_skip_u128 = can_skip as u128;
@@ -450,12 +453,16 @@ where
                     // took longer to get rescheduled than we wanted
                     self.timer.skip(can_skip);
                     let ticks = elapsed - can_skip_u128;
+                    // cap catch-up iterations per call to avoid starving the message
+                    // queue when the thread was suspended for a long time.
+                    let ticks = ticks.min(Self::MAX_CATCH_UP_TICKS);
                     for _ in 0..ticks {
                         self.tick();
                     }
                 }
                 Ordering::Less => {
                     // we got woken up early, no need to tick
+                    // Safety: elapsed < can_skip (u32), so elapsed fits in u32.
                     self.timer.skip(elapsed as u32);
                 }
                 Ordering::Equal => {

Original file line number	Diff line number	Diff line change
`@@ -440,6 +440,9 @@ where`
`440`	`440`	`}`
`441`	`441`	`}`
`442`	`442`
	`443`	+ /// Maximum number of catch-up ticks processed in a single `skip_and_tick` call.
	`444`	`+ const MAX_CATCH_UP_TICKS: u128 = 1_000;`
	`445`	`+`
`443`	`446`	`#[inline(always)]`
`444`	`447`	`fn skip_and_tick(&mut self, can_skip: u32, elapsed: u128) {`
`445`	`448`	`let can_skip_u128 = can_skip as u128;`
`@@ -450,12 +453,16 @@ where`
`450`	`453`	`// took longer to get rescheduled than we wanted`
`451`	`454`	`self.timer.skip(can_skip);`
`452`	`455`	`let ticks = elapsed - can_skip_u128;`
	`456`	`+ // cap catch-up iterations per call to avoid starving the message`
	`457`	`+ // queue when the thread was suspended for a long time.`
	`458`	`+ let ticks = ticks.min(Self::MAX_CATCH_UP_TICKS);`
`453`	`459`	`for _ in 0..ticks {`
`454`	`460`	`self.tick();`
`455`	`461`	`}`
`456`	`462`	`}`
`457`	`463`	`Ordering::Less => {`
`458`	`464`	`// we got woken up early, no need to tick`
	`465`	`+ // Safety: elapsed < can_skip (u32), so elapsed fits in u32.`
`459`	`466`	`self.timer.skip(elapsed as u32);`
`460`	`467`	`}`
`461`	`468`	`Ordering::Equal => {`