use super::*;
const VIRTUAL_IDLE_FAILED_ATTEMPTS_PER_TICK: u8 = 3;
const VIRTUAL_IDLE_MAX_PASS_STEPS: u64 = 1 << 13;
pub(crate) fn virtual_idle_trap_is_journal_complete(
opcode: u16,
null_event: bool,
system_task_idle: bool,
sound_command_rejected: bool,
selector: u32,
ui_tracking: bool,
) -> bool {
idle_cycle_trap_is_journal_complete(
opcode,
null_event,
system_task_idle,
sound_command_rejected,
selector,
false,
) || (!ui_tracking
&& canonical_trap_number(opcode) == (true, 0x0000)
&& matches!(selector, 0x0010_0008 | 0x0510_0008))
|| (!ui_tracking
&& matches!(
canonical_trap_number(opcode),
(true, 0x007E..=0x0081)
| (true, 0x00A6..=0x00AC)
| (true, 0x00AE)
| (true, 0x0058..=0x005F)
| (true, 0x0073)
| (true, 0x0074)
| (true, 0x0231)
| (true, 0x0232)
| (true, 0x0053)
| (true, 0x0055)
| (true, 0x0017)
))
}
fn virtual_idle_trap_reads_event_queue(opcode: u16) -> bool {
event_manager_yield_trap(opcode)
|| matches!(canonical_trap_number(opcode), (true, 0x0173 | 0x0174))
}
#[derive(Clone, PartialEq)]
pub(crate) struct IdleProverState {
probe: bool,
counter: bool,
sleep: bool,
last_seen: Option<(u32, u32)>,
sites: [IdleCycleSiteRecord; IDLE_CYCLE_SITE_SLOTS],
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub(crate) struct RecordedPass {
pub(crate) steps: u64,
pub(crate) extra_units: Vec<(u64, i64)>,
pub(crate) start_values: Vec<(u32, u32)>,
pub(crate) reads_event_queue: bool,
pub(crate) browser_bounded: bool,
}
impl RecordedPass {
pub(crate) fn units_to(&self, offset: u64) -> i64 {
offset as i64
+ self
.extra_units
.iter()
.take_while(|(at, _)| *at <= offset)
.map(|(_, units)| *units)
.sum::<i64>()
}
pub(crate) fn units_after(&self, offset: u64, count: u64) -> i64 {
let end = offset + count;
let passes = (end / self.steps) as i64;
passes * self.units_to(self.steps) + self.units_to(end % self.steps) - self.units_to(offset)
}
pub(crate) fn steps_within(&self, offset: u64, limit: u64, units: i64) -> u64 {
if units <= 0 {
return 0;
}
let (mut low, mut high) = (0u64, limit);
while low < high {
let mid = low + (high - low).div_ceil(2);
if self.units_after(offset, mid) <= units {
low = mid;
} else {
high = mid - 1;
}
}
low
}
}
pub(crate) struct PassRecorder {
pub(crate) prover: IdleProverState,
pub(crate) host: IdleCycleHostSnapshot,
pub(crate) trap_pc: u32,
pub(crate) tick: u32,
pub(crate) cpu: CpuArchitecturalSnapshot,
pub(crate) arrivals: u8,
pub(crate) start_instructions: u64,
pub(crate) start_budget: i32,
pub(crate) executed: u64,
pub(crate) extra_units: Vec<(u64, i64)>,
pub(crate) reads_event_queue: bool,
pub(crate) browser_bounded: bool,
pub(crate) native_returns: Vec<u32>,
}
pub(crate) struct VirtualIdleCycle {
pub(crate) tick: u32,
pub(crate) pass: RecordedPass,
pub(crate) offset: u64,
pub(crate) host: IdleCycleHostSnapshot,
pub(crate) start: PassStart,
}
pub(crate) struct PassStart {
pub(crate) trap_pc: u32,
pub(crate) cpu: CpuArchitecturalSnapshot,
pub(crate) prover: IdleProverState,
pub(crate) native_returns: Vec<u32>,
}
pub(crate) struct KeptIdleRecording {
pub(crate) tick: u32,
pub(crate) pass: RecordedPass,
pub(crate) host: IdleCycleHostSnapshot,
pub(crate) start: PassStart,
pub(crate) journal: u64,
}
impl FixtureRunner {
pub(crate) fn virtual_idle_allowed(&self) -> bool {
self.virtual_idle_enabled
&& !per_instruction_diagnostics_active()
&& !trace_opcode_counts_enabled()
&& !trace_hot_pc_enabled()
&& self.debug_step_units_remaining().is_none()
&& self.bus.guest_ram_is_identity_mapped()
}
fn idle_prover_state(&self) -> IdleProverState {
IdleProverState {
probe: self.idle_cycle_probe.is_some(),
counter: self.idle_counter.is_some(),
sleep: self.idle_cycle_sleep.is_some(),
last_seen: self.idle_cycle_last_seen,
sites: self.idle_cycle_sites,
}
}
fn idle_prover_owns_journal(&self) -> bool {
self.idle_cycle_probe.is_some() || self.idle_cycle_sleep.is_some()
}
fn begin_pass_recording(&mut self, trap_pc: u32, tick: u32, cpu: CpuArchitecturalSnapshot) {
self.bus.begin_write_probe();
self.pass_recorder = Some(PassRecorder {
prover: self.idle_prover_state(),
host: IdleCycleHostSnapshot::capture(&self.dispatcher),
trap_pc,
tick,
cpu,
arrivals: 0,
start_instructions: self.total_instructions,
start_budget: self.tick_budget,
executed: 0,
extra_units: Vec::new(),
reads_event_queue: false,
browser_bounded: true,
native_returns: self.native_trap_return_pcs(),
});
}
fn native_trap_call_count(&self) -> usize {
self.dispatcher.pending_native_trap_call_count()
}
fn native_trap_return_pcs(&self) -> Vec<u32> {
let mut pcs = Vec::new();
self.dispatcher.append_pending_native_trap_return_pcs(&mut pcs);
pcs.sort_unstable();
pcs
}
pub(crate) fn cancel_pass_recording(&mut self) {
if self.pass_recorder.take().is_some() && !self.idle_prover_owns_journal() {
self.bus.cancel_write_probe();
}
}
pub(crate) fn record_pass_trap(
&mut self,
opcode: u16,
null_event: bool,
input_selector: u32,
extra_units: i32,
) {
let Some(mut recorder) = self.pass_recorder.take() else {
return;
};
let offset = self.total_instructions - recorder.start_instructions;
recorder.reads_event_queue |= virtual_idle_trap_reads_event_queue(opcode);
recorder.browser_bounded &= self.dispatcher.last_trap_is_bounded_query(&self.bus);
let plain = offset <= VIRTUAL_IDLE_MAX_PASS_STEPS
&& self.native_trap_call_count() == recorder.native_returns.len()
&& self.virtual_pass_trap_is_plain(opcode, null_event, input_selector);
if extra_units > 0 {
recorder.extra_units.push((offset, i64::from(extra_units)));
}
self.pass_recorder = Some(recorder);
if !plain {
self.cancel_pass_recording();
}
}
fn virtual_pass_trap_is_plain(
&self,
opcode: u16,
null_event: bool,
input_selector: u32,
) -> bool {
let sound_command_rejected = canonical_trap_number(opcode) == (true, 0x0003)
&& self.bus.read_word(self.m68k.cpu.core.a(7)) as i16 == SOUND_QUEUE_FULL;
!self.idle_prover_owns_journal()
&& self.active_interrupt_callback.is_none()
&& !(matches!(
canonical_trap_number(opcode),
(true, 0x0053 | 0x0055 | 0x0231 | 0x0232)
)
&& self.dispatcher.has_native_trap_patch(&self.bus, opcode))
&& !self.idle_query_has_unsafe_dispatch(opcode)
&& virtual_idle_trap_is_journal_complete(
opcode,
null_event,
!self.dispatcher.system_task_has_periodic_work(&self.bus),
sound_command_rejected,
input_selector,
self.is_ui_tracking_active(),
)
}
pub(crate) fn note_virtual_anchor_arrival(&mut self, trap_pc: u32) {
self.note_virtual_anchor_arrival_inner(trap_pc, false);
}
pub(crate) fn note_virtual_device_anchor_arrival(&mut self, trap_pc: u32) {
self.note_virtual_anchor_arrival_inner(trap_pc, true);
}
fn note_virtual_anchor_arrival_inner(&mut self, trap_pc: u32, device_anchor: bool) {
if self.pass_recorder.is_some() && self.idle_prover_owns_journal() {
self.pass_recorder = None;
}
if !self.virtual_idle_allowed() || self.virtual_idle_cycle.is_some() {
return;
}
let tick = self.guest_tick();
let snapshot = |runner: &Self| CpuArchitecturalSnapshot::capture(&runner.m68k.cpu.core);
if self
.virtual_idle_kept
.as_ref()
.is_some_and(|kept| kept.start.trap_pc == trap_pc || kept.tick != tick)
{
let kept = self.virtual_idle_kept.take().unwrap();
if self.resume_kept_idle_recording(kept, tick, &snapshot(self)) {
return;
}
}
if let Some(recorder) = self.pass_recorder.as_ref() {
if recorder.trap_pc != trap_pc || recorder.tick != tick {
return;
}
if snapshot(self) != self.pass_recorder.as_ref().unwrap().cpu {
let recorder = self.pass_recorder.as_mut().unwrap();
recorder.arrivals += 1;
if recorder.arrivals >= IDLE_CYCLE_MAX_PERIOD {
self.cancel_pass_recording();
}
return;
}
self.close_pass_recording(tick);
return;
}
if self.idle_prover_owns_journal()
|| self.idle_counter.is_some()
|| (!device_anchor && !self.idle_cycle_site_is_busy(trap_pc, tick))
{
return;
}
let slot = self
.virtual_idle_attempts
.iter()
.position(|&(site, _, _)| site == trap_pc)
.unwrap_or_else(|| {
self.virtual_idle_attempts
.iter()
.enumerate()
.min_by_key(|(_, &(_, at, _))| at)
.map(|(index, _)| index)
.unwrap()
});
let (site, at, failures) = self.virtual_idle_attempts[slot];
let failures = if site == trap_pc && at == tick { failures } else { 0 };
if failures >= VIRTUAL_IDLE_FAILED_ATTEMPTS_PER_TICK {
return;
}
self.virtual_idle_attempts[slot] = (trap_pc, tick, failures + 1);
let cpu = snapshot(self);
self.begin_pass_recording(trap_pc, tick, cpu);
}
fn close_pass_recording(&mut self, tick: u32) {
let recorder = self.pass_recorder.take().unwrap();
let recorder_site = recorder.trap_pc;
let mut start_values = Vec::new();
let journal_ok = self.bus.write_probe_words(&mut start_values);
let restored = self.bus.finish_write_probe_changes();
let steps = self.total_instructions - recorder.start_instructions;
let extra: i64 = recorder.extra_units.iter().map(|&(_, units)| units).sum();
if !journal_ok
|| restored.as_ref().is_none_or(|changes| !changes.is_empty())
|| recorder.prover != self.idle_prover_state()
|| recorder.host != IdleCycleHostSnapshot::capture(&self.dispatcher)
|| recorder.native_returns != self.native_trap_return_pcs()
|| steps == 0
|| steps > VIRTUAL_IDLE_MAX_PASS_STEPS
|| recorder.executed != steps
|| i64::from(recorder.start_budget) - i64::from(self.tick_budget) != steps as i64 + extra
{
return;
}
start_values.sort_unstable();
if let Some(slot) = self
.virtual_idle_attempts
.iter_mut()
.find(|(site, _, _)| *site == recorder_site)
{
slot.2 = 0;
}
self.virtual_idle_entries += 1;
self.virtual_idle_cycle = Some(VirtualIdleCycle {
tick,
pass: RecordedPass {
steps,
extra_units: recorder.extra_units,
start_values,
reads_event_queue: recorder.reads_event_queue,
browser_bounded: recorder.browser_bounded,
},
offset: 0,
host: IdleCycleHostSnapshot::capture(&self.dispatcher),
start: PassStart {
trap_pc: recorder.trap_pc,
cpu: recorder.cpu,
prover: recorder.prover,
native_returns: recorder.native_returns,
},
});
}
fn virtual_idle_cycle_is_quiet(&mut self, sound_work_only: bool) -> bool {
let Some(cycle) = self.virtual_idle_cycle.as_ref() else {
return false;
};
let (tick, host, reads_event_queue) =
(cycle.tick, cycle.host.clone(), cycle.pass.reads_event_queue);
!sound_work_only
&& !self.halted
&& self.guest_tick() == tick
&& self.active_interrupt_callback.is_none()
&& self.frozen_ticks.is_none()
&& !self.callback_suspends_guest_clock()
&& !self.has_pending_sound_work()
&& !self.dispatcher.vbl_tasks.with_ref(|tasks| {
tasks
.iter()
.any(|task| task.architecture == CallbackTaskArchitecture::M68k && task.pending)
})
&& self.dispatcher.pending_file_completions.is_empty()
&& !self.dispatcher.adb.has_pending_packet()
&& self.dispatcher.deferred_tasks.is_empty()
&& self.dispatcher.pending_wait_sleep_ticks == 0
&& self.dispatcher.pending_delay_ticks == 0
&& self.dispatcher.pending_launch_app.is_none()
&& self.deferred_tracking_refire_pc.is_none()
&& !self.dispatcher.has_ready_menu_tracking()
&& self.dispatcher.input_state.key_repeat().is_none_or(|repeat| {
self.guest_tick().wrapping_sub(repeat.next_tick()) >= 0x8000_0000
})
&& !self.dispatcher.system_task_has_periodic_work(&self.bus)
&& self
.next_m68k_timer_subtick()
.is_none_or(|due| due > self.current_timer_subtick())
&& host == IdleCycleHostSnapshot::capture(&self.dispatcher)
&& (!reads_event_queue
|| self.dispatcher.peek_toolbox_event(&self.bus, u16::MAX).is_none())
}
fn units_before_next_m68k_timer(&self) -> Option<i64> {
const SUBTICKS_PER_TICK: i128 = 1_000_000;
let due = self.next_m68k_timer_subtick()?;
let per_tick = i128::from(self.instructions_per_tick.max(1));
let tick_base = i128::from(self.guest_tick()) * SUBTICKS_PER_TICK;
let room = i128::from(due) - tick_base;
if room >= SUBTICKS_PER_TICK {
return None;
}
let elapsed = per_tick - i128::from(self.tick_budget.max(0)).min(per_tick);
let limit = (room * per_tick + SUBTICKS_PER_TICK - 1) / SUBTICKS_PER_TICK - 1 - elapsed;
Some(limit.clamp(0, i128::from(i64::MAX)) as i64)
}
pub(crate) fn advance_virtual_idle_cycle(&mut self, limit: usize, sound_work_only: bool) -> usize {
if self.virtual_idle_cycle.is_none() {
return 0;
}
if !self.virtual_idle_cycle_is_quiet(sound_work_only) {
self.materialize_virtual_idle_cycle();
return 0;
}
let mut units = i64::from(self.tick_budget) - 2;
if let Some(timer) = self.units_before_next_m68k_timer() {
units = units.min(timer);
}
let cycle = self.virtual_idle_cycle.as_mut().unwrap();
let steps = cycle.pass.steps_within(cycle.offset, limit as u64, units);
if steps == 0 {
self.materialize_virtual_idle_cycle();
return 0;
}
let charged = cycle.pass.units_after(cycle.offset, steps);
cycle.offset = (cycle.offset + steps) % cycle.pass.steps;
self.total_instructions = self.total_instructions.wrapping_add(steps);
self.tick_budget -= charged as i32;
if (steps as usize) < limit {
self.materialize_virtual_idle_cycle();
}
steps as usize
}
pub(crate) fn materialize_virtual_idle_cycle(&mut self) {
let _ = self.take_materialized_virtual_idle_cycle();
}
pub(crate) fn keep_virtual_idle_cycle_across_slice(&mut self) {
let Some(cycle) = self.take_materialized_virtual_idle_cycle() else {
return;
};
if self.idle_prover_owns_journal() {
return;
}
self.bus.begin_write_probe();
self.virtual_idle_kept = Some(KeptIdleRecording {
tick: cycle.tick,
pass: cycle.pass,
host: cycle.host,
start: cycle.start,
journal: self.bus.write_probe_generation(),
});
}
pub(crate) fn drop_kept_idle_recording(&mut self) {
if let Some(kept) = self.virtual_idle_kept.take() {
if self.kept_journal_is_armed(&kept) {
self.bus.cancel_write_probe();
}
}
}
fn kept_journal_is_armed(&self, kept: &KeptIdleRecording) -> bool {
self.bus.write_probe_generation() == kept.journal && !self.idle_prover_owns_journal()
}
fn resume_kept_idle_recording(
&mut self,
kept: KeptIdleRecording,
tick: u32,
cpu: &CpuArchitecturalSnapshot,
) -> bool {
let armed = self.kept_journal_is_armed(&kept);
let mut journaled = Vec::new();
let journal_ok = armed && self.bus.write_probe_words(&mut journaled);
if armed {
self.bus.cancel_write_probe();
}
if !journal_ok
|| tick != kept.tick
|| *cpu != kept.start.cpu
|| self.idle_prover_state() != kept.start.prover
|| self.native_trap_return_pcs() != kept.start.native_returns
|| IdleCycleHostSnapshot::capture(&self.dispatcher) != kept.host
{
return false;
}
let at_start = journaled.iter().all(|&(word, before)| {
let start = match kept.pass.start_values.binary_search_by_key(&word, |&(w, _)| w) {
Ok(index) => kept.pass.start_values[index].1,
Err(_) => before,
};
self.bus.journaled_word(word) == start
});
if !at_start {
return false;
}
self.virtual_idle_entries += 1;
self.virtual_idle_cycle = Some(VirtualIdleCycle {
tick,
pass: kept.pass,
offset: 0,
host: kept.host,
start: kept.start,
});
true
}
fn take_materialized_virtual_idle_cycle(&mut self) -> Option<VirtualIdleCycle> {
let cycle = self.virtual_idle_cycle.take()?;
for &(word, value) in &cycle.pass.start_values {
if self.bus.journaled_word(word) != value {
self.bus.write_long(word, value);
}
}
let expected_budget = self.tick_budget;
self.tick_budget += cycle.pass.units_to(cycle.offset) as i32;
self.replay_idle_steps(cycle.offset);
debug_assert_eq!(self.tick_budget, expected_budget);
self.tick_budget = expected_budget;
Some(cycle)
}
fn replay_idle_steps(&mut self, mut steps: u64) {
while steps > 0 && !self.halted {
let previous_mouse = self.bus.read_long(crate::memory::globals::addr::MOUSE_LOC2);
let batch = self
.m68k
.cpu
.run_batch(&mut self.bus, steps.min(u64::from(u32::MAX)) as u32, &[0]);
self.sync_guest_mouse_position(previous_mouse);
self.dispatcher
.retire_returned_native_trap_call(&mut self.m68k.cpu);
let executed = u64::from(batch.instructions)
+ u64::from(matches!(
batch.exit,
BatchExit::AlineTrap { .. } | BatchExit::FlineTrap { .. }
));
steps = steps.saturating_sub(executed);
self.tick_budget -= executed as i32;
match batch.exit {
BatchExit::BudgetExhausted | BatchExit::WatchedPc { .. } => {}
BatchExit::AlineTrap { opcode } => {
if self.dispatch_classic_with_process_services(opcode).is_err() {
self.halted = true;
return;
}
let extra = hle_trap_extra_tick_cost(opcode)
.saturating_add(self.dispatcher.take_hle_tick_cost());
self.tick_budget -= extra;
}
_ => return,
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::event_queue::QueuedEvent;
#[test]
fn pending_event_blocks_only_recordings_that_read_the_queue() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner.dispatcher.set_sent_open_app_event_for_test(true);
runner.dispatcher.event_queue.push_back(QueuedEvent {
what: 1, message: 0, when: 0, where_v: 10, where_h: 20, modifiers: 0,
});
assert!(runner.dispatcher.peek_toolbox_event(&runner.bus, u16::MAX).is_some());
runner.virtual_idle_cycle = Some(VirtualIdleCycle {
tick: runner.guest_tick(),
pass: RecordedPass { steps: 1, ..RecordedPass::default() },
offset: 0,
host: IdleCycleHostSnapshot::capture(&runner.dispatcher),
start: PassStart {
trap_pc: 0,
cpu: CpuArchitecturalSnapshot::capture(&runner.m68k.cpu.core),
prover: runner.idle_prover_state(),
native_returns: runner.native_trap_return_pcs(),
},
});
assert!(runner.virtual_idle_cycle_is_quiet(false), "a cycle that never reads events can proceed");
runner.virtual_idle_cycle.as_mut().unwrap().pass.reads_event_queue = true;
assert!(!runner.virtual_idle_cycle_is_quiet(false), "an event-reading cycle must materialize");
for trap in [0xA860u16, 0xA970, 0xA971, 0xA973, 0xA974] {
assert!(virtual_idle_trap_reads_event_queue(trap), "{trap:04x}");
}
for trap in [0xA800u16, 0xA972, 0xA975, 0xA976] {
assert!(!virtual_idle_trap_reads_event_queue(trap), "{trap:04x}");
}
}
#[test]
fn virtual_idle_requires_repeat_not_due_and_invalidates_repeat_changes() {
let mut runner = FixtureRunner::new(8 * 1024 * 1024, FixtureRunnerConfig::default());
runner
.dispatcher
.set_tick_count_for_test(&mut runner.bus, u32::MAX - 4);
let tick = runner.guest_tick();
runner
.dispatcher
.input_state
.arm_key_repeat(0x7b, 0x1c, tick.wrapping_add(10));
runner.virtual_idle_cycle = Some(VirtualIdleCycle {
tick,
pass: RecordedPass {
steps: 1,
..RecordedPass::default()
},
offset: 0,
host: IdleCycleHostSnapshot::capture(&runner.dispatcher),
start: PassStart {
trap_pc: 0,
cpu: CpuArchitecturalSnapshot::capture(&runner.m68k.cpu.core),
prover: runner.idle_prover_state(),
native_returns: runner.native_trap_return_pcs(),
},
});
assert!(
runner.virtual_idle_cycle_is_quiet(false),
"future repeat across wrap"
);
runner.tick_budget = 100;
let before = runner.total_instructions;
assert_eq!(runner.advance_virtual_idle_cycle(3, false), 3);
assert_eq!(runner.total_instructions, before + 3);
runner
.dispatcher
.input_state
.arm_key_repeat(0x7c, 0x1d, tick.wrapping_add(10));
assert!(
!runner.virtual_idle_cycle_is_quiet(false),
"re-arming invalidates host snapshot"
);
runner.virtual_idle_cycle.as_mut().unwrap().host =
IdleCycleHostSnapshot::capture(&runner.dispatcher);
runner.dispatcher.input_state.clear_key_repeat();
assert!(
!runner.virtual_idle_cycle_is_quiet(false),
"release invalidates host snapshot"
);
for due in [tick, tick.wrapping_sub(1)] {
runner
.dispatcher
.input_state
.arm_key_repeat(0x7b, 0x1c, due);
runner.virtual_idle_cycle.as_mut().unwrap().host =
IdleCycleHostSnapshot::capture(&runner.dispatcher);
assert!(
!runner.virtual_idle_cycle_is_quiet(false),
"due or past repeat must materialize"
);
}
}
fn pass() -> RecordedPass {
RecordedPass {
steps: 10,
extra_units: vec![(3, 5), (10, 2)],
start_values: Vec::new(),
reads_event_queue: false,
browser_bounded: true,
}
}
#[test]
fn a_trap_charges_its_extra_units_at_its_own_step() {
let pass = pass();
assert_eq!(pass.units_to(0), 0);
assert_eq!(pass.units_to(2), 2);
assert_eq!(pass.units_to(3), 8);
assert_eq!(pass.units_to(9), 14);
assert_eq!(pass.units_to(10), 17);
}
#[test]
fn units_after_cross_pass_boundaries() {
let pass = pass();
assert_eq!(pass.units_after(8, 5), 12);
assert_eq!(pass.units_after(0, 25), 2 * 17 + 10);
assert_eq!(pass.units_after(7, 0), 0);
for offset in 0..10 {
assert_eq!(pass.units_after(offset, 10), 17, "a whole pass from {offset}");
}
}
#[test]
fn steps_within_is_the_longest_run_that_fits() {
let pass = pass();
for offset in 0..10 {
for units in 0..60 {
for limit in [0, 7, 40] {
let steps = pass.steps_within(offset, limit, units);
assert!(steps <= limit);
assert!(steps == 0 || pass.units_after(offset, steps) <= units);
assert!(
steps == limit || pass.units_after(offset, steps + 1) > units,
"offset {offset}, {units} units, limit {limit}: {steps} is not the longest"
);
}
}
}
}
}