badline 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c6abfa72fe3a5e5f8e88efe9d53e04b4e6eaeb355550ef5ac23c47c1a0916fc
-  data.tar.gz: e15d996a7121eb244ba6ad7a8870694389f59ab8139977b2cf7b9d344f35bbe7
+  metadata.gz: 9175400f11b212812092f887bea13e0880417fb151011fdbc568c4789050dcf1
+  data.tar.gz: dbd07633e45bfcc06fd6b4ab1b680389276ff81340cc6c72d26bd4e7fdf6baad
 SHA512:
-  metadata.gz: d6fdecfc6b65d6b67d296fafb91e1cbdad7920e0326f146c5bae4bfed08fdd3fad9b4b38007a7f3bdb6a859ff5f1428ff7d94f573e13b68dfdb2e31c5c15e9fe
-  data.tar.gz: 6843561cca4725f4d6a93cff613ea9b0a9db78d1d45aebee9c4ba7573c49205b0162c4431d4cb78b81e12ded0e84388866017e88b94e065790934e2aaa0c4e8e
+  metadata.gz: d00a54fba0e530ff578a35b3b5953c0f011b6ea32a2b5ac3f8ccaf19dc8c8f3e26bb81dedfac4c53b026b0e2d0a8e3a35c9f212369624995765c0c8a99678542
+  data.tar.gz: '0918a31ea33114c1f46d76ec3c0e9978a5e922bd7b39f6abe9494ee03423fad48f4aecbf8c4a2e0af4414ee19b2ce2d33c6cb21774a473138db15a588c149f2b'

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.5.1](https://github.com/elektronaut/badline/compare/v0.5.0...v0.5.1) (2026-09-29)
+
+
+### Bug Fixes
+
+* build the native badline with a Spinel that writes .d64 images through the true drive ([97f537a](https://github.com/elektronaut/badline/commit/97f537afe69b10ae044f83ccf4dd018402ebe1be))
+
+
+### Performance Improvements
+
+* sleep the idle true drive through its timer interrupts ([0482e43](https://github.com/elektronaut/badline/commit/0482e439cfb160ab69027b166b1059ed8fc9dfb3)), closes [#367](https://github.com/elektronaut/badline/issues/367)
+
 ## [0.5.0](https://github.com/elektronaut/badline/compare/v0.4.2...v0.5.0) (2026-09-29)
 
 

data/CLAUDE.md

@@ -48,6 +48,7 @@ requires only the namespace file.
 | Wolfgang Lorenz suite | `bin/lorenz` | CPU, CIA, interrupts |
 | VICE testbench | `bin/testbench <subtree>` | `VICII/`, `CIA/`, `interrupts/`, `CPU/`, cartridges with `--carts`, and the true 1541 drive with `--drive` |
 | VICE SID testprogs | `bin/sidtests` | SID |
+| Drive scenarios | `bin/drive_scenarios` | The true 1541 running the DOS ROM: save, format, the error channel, idle, write protect and autostart |
 | CIA offline grids | `bundle exec rspec --tag slow spec/badline/cia` | CIA timers and shift register, against a bare CIA in about 2 min |
 
 The CIA offline grids replay Lorenz's `cia1ta` and `cia1tb` sweeps (about
@@ -156,29 +157,29 @@ the rows your change can't reach tell you nothing about it.
   `ruby --yjit bin/lorenz [image] [start_test] [max_cycles]` (resumes the
   chain at a named test, and `--stop-after NAME` ends it once that test is
   done). These take seconds to minutes
-- When your change moves rows, re-record only those rows, in the same
-  change: `rake "regression:record:<suite>[filter,...]"` (quote it, because
-  zsh globs the brackets). It runs only the matching tests and splices
-  their rows into the baseline, and every other row keeps its verdict.
+- A pull request's CI is the verdict. It runs every suite but
+  `testbench-drive` on the Spinel build, compared row by row against
+  `test/baselines/`, and every job is a required check. A row that moved
+  fails it. Re-record only those rows, in the same change:
+  `rake "regression:record:<suite>[filter,...]"` (quote it, because zsh
+  globs the brackets). It runs only the matching tests on CRuby and
+  splices their rows into the baseline, and every other row keeps its
+  verdict. CI runs the same rows on Spinel, so the two have to agree.
   `lorenz` chains itself, so it takes a stretch of the chain instead:
   `rake "regression:record:lorenz[first,last]"` resumes just ahead of
   `first`, stops after `last` and leaves the `(suite)` row alone.
   `[first,(suite)]` runs on to the end of the chain and records the
-  `(suite)` row too. Cover every test your change can reach, and explain
-  every moved row. Never re-record just to make a diff go away
-- CI's nightly run owns the whole-suite verdict. The Regression workflow
-  runs `testbench`, `lorenz` and `sid` against `main` each night, and skips
-  the night when nothing relevant has changed since the last successful
-  nightly run. It also runs from the Actions tab on demand. It never runs
-  on push or on pull requests, so one verdict can cover a day's merges.
-  The `testbench-*` and `sid-8580` suites run from the Actions tab on
-  demand. The Spinel workflow runs the Spinel suites on pull requests
-  that touch emulation, harness or build paths. Its jobs aren't required
-  checks yet, and the CRuby Regression nightly runs as before
-- The one exception is a change whose reach you can't bound to a set of
-  filters, such as reordering `Computer#cycle!` or changing the LOAD trap
-  every suite loads through. Ask before running a full suite for it, and
-  don't start one on your own judgement
+  `(suite)` row too. Explain every moved row in the pull request. Never
+  re-record just to make a diff go away
+- For a change whose reach you can't bound to a set of filters, such as
+  reordering `Computer#cycle!` or changing the LOAD trap every suite loads
+  through, push and let CI run the suites
+- `testbench-drive` needs the true drive, which the Spinel testbench
+  harness doesn't have, so CI leaves it out. Run the rows your change can
+  reach locally
+- The Regression workflow runs the suites on CRuby, started by hand from
+  the Actions tab, for a person checking that CRuby and Spinel agree.
+  Agents don't start it
 
 Pick the filters from the suites your change can move: VIC → `testbench`,
 plus `testbench-vicii-new` (`bin/testbench --vicii-new`, the 8565) for
@@ -190,10 +191,9 @@ CPU, interrupts or timing → the matching `testbench-*` suite, plus
 the 6526A) for anything the interrupt register or the CIA model reaches; cartridge mappers, banking or power-on state →
 `testbench-carts`, plus `testbench-expansions` for banking; GEO-RAM, +60K,
 +256K, the REU or the VIC's BA line the REU follows → `testbench-expansions`; the 1541 drive, VIA or IEC bus →
-`testbench-drive` (`bin/testbench --drive`); SID → `sid`, plus `sid-8580` for anything the 8580
-model reaches (`bin/sidtests --sid 8580`). Lorenz isn't a per-change check:
-its full chain runs nightly, and the planner assigns any row it moves. The
-exception is code whose rule in `doc/pinned-behaviour.md` names Lorenz
+`testbench-drive` (`bin/testbench --drive`) and `drive-scenarios` (`bin/drive_scenarios <filter>`); SID → `sid`, plus `sid-8580` for anything the 8580
+model reaches (`bin/sidtests --sid 8580`). Leave the Lorenz chain to CI,
+unless your code has a rule in `doc/pinned-behaviour.md` that names Lorenz
 tests: the interrupt polling, CPU port and CIA timer rules. Run just the
 tests that rule names, one at a time, with
 `ruby --yjit bin/lorenz --resume <test> --stop-after <test>`. A stretch

data/CONTRIBUTING.md

@@ -85,6 +85,11 @@ bundle exec rubocop
 ## Tests and commits
 
 - Add tests for any behavior you change.
+- CI runs rubocop, the specs and every regression suite on each pull
+  request, and fails on any suite row that differs from its baseline in
+  `test/baselines/`. When a change moves rows on purpose, re-record just
+  those rows as [test/baselines/README.md](test/baselines/README.md)
+  describes, and say why in the pull request.
 - Write commit messages using
   [Conventional Commits](https://www.conventionalcommits.org). The
   changelog and releases are generated from them, so the `feat:` and

data/README.md

@@ -1,5 +1,5 @@
 [![Version](https://img.shields.io/gem/v/badline.svg?style=flat)](https://rubygems.org/gems/badline)
-[![Build](https://github.com/elektronaut/badline/actions/workflows/build.yml/badge.svg)](https://github.com/elektronaut/badline/actions/workflows/build.yml)
+[![CI](https://github.com/elektronaut/badline/actions/workflows/ci.yml/badge.svg)](https://github.com/elektronaut/badline/actions/workflows/ci.yml)
 
 # Badline
 

data/doc/pinned-behaviour.md

@@ -1203,8 +1203,10 @@ and each was knocked out: removing it fails the rows named.
   - Spec guard: *steps in from the stop with the first phase after the
     bump* in
     [`mechanism_spec.rb`](../spec/badline/drive1541/mechanism_spec.rb),
-    and *lists it through the traps* (`:slow`) in
-    [`drive1541_spec.rb`](../spec/badline/drive1541_spec.rb).
+    and the `format/name-and-id`, `format/bam-free` and
+    `format/trap-readable` rows of the `drive-scenarios` suite
+    ([`drive_scenarios.rb`](../test/drive_scenarios.rb)), which read the
+    formatted disk back from its image.
 - The disk turns at 300 rpm whatever bit rate VIA 2's PB5-6 select: a
   turn is 200,000 drive cycles over every track and over a half track
   without data. Each track's bits pass under the head at the rate they

data/lib/badline/cia.rb

@@ -62,6 +62,7 @@ module Badline
 
       @peripheral = peripheral
       @port_b4_handler = nil
+      @port_a_handler = nil
       @port_b4_high = true
       reset!
     end
@@ -87,6 +88,7 @@ module Badline
       @ta = Timer.new(@control_a)
       @tb = Timer.new(@control_b)
       @serial = Serial.new(@control_a)
+      @port_a_handler&.call
     end
 
     # Register a change handler on the PB4 line. On CIA 1, this feeds the
@@ -95,6 +97,13 @@ module Badline
       @port_b4_handler = handler
     end
 
+    # Register a handler for writes that can move port A's lines: to the
+    # data register or DDR, and the reset. On CIA 2, this tells the drives
+    # on the serial bus that the C64 may have moved a line.
+    def on_port_a_write(&handler)
+      @port_a_handler = handler
+    end
+
     # A falling edge on the FLAG pin. On CIA 1 the datasette's tape read
     # line drives it, on CIA 2 the serial bus SRQ.
     def flag! = raise_interrupt(:flag)
@@ -153,9 +162,9 @@ module Badline
 
     def poke(addr, value)
       case offset_of(addr) & 0x0f
-      when 0x00 then @data_port_a = value
+      when 0x00 then update_port_a { @data_port_a = value }
       when 0x01 then update_port_b { @data_port_b = value }
-      when 0x02 then @data_dir_a = value
+      when 0x02 then update_port_a { @data_dir_a = value }
       when 0x03 then update_port_b { @data_dir_b = value }
       when 0x04 then @ta.write_latch_low(value)
       when 0x05 then @ta.write_latch_high(value)
@@ -174,6 +183,11 @@ module Badline
 
     private
 
+    def update_port_a
+      yield
+      @port_a_handler&.call
+    end
+
     def update_port_b
       yield
       @port_b4_driven_high = driven_lines(@data_port_b, @data_dir_b).anybits?(0x10)

data/lib/badline/computer.rb

@@ -195,7 +195,7 @@ module Badline
     # for, which plugging in a drive does. Until then port A's serial
     # inputs float high.
     def iec_bus
-      @iec_bus ||= IECBus.new(host: @cia2).tap { |bus| @cia2.peripheral = bus }
+      @iec_bus ||= IECBus.new(host: @cia2).tap(&:plug_in!)
     end
 
     def capture_output

data/lib/badline/drive1541/bus.rb

@@ -19,7 +19,8 @@ module Badline
     # both on a real 1541.
     #
     # While Idle records a pass of the DOS's idle loop, the bus watches it
-    # (see watch!).
+    # (see watch!). While Idle looks for an orbit, the bus guards the drive
+    # (see guard!).
     class Bus
       include Addressable
 
@@ -31,6 +32,10 @@ module Badline
       VOLATILE_VIA2_READS = 0x0730
       VOLATILE_VIA2_WRITES = 0x0ff0
 
+      # The timer each VIA register reaches, by offset, as bits: 1 for
+      # timer 1 and 2 for timer 2.
+      TIMER_REGISTERS = [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 0, 0, 0, 0, 0, 0].freeze
+
       attr_reader :ram, :rom, :via1, :via2, :data
 
       # Whether a watched stretch did something that makes it unrepeatable.
@@ -40,6 +45,14 @@ module Badline
       # from before the first access.
       attr_reader :touched
 
+      # Whether the drive did something since guard! that reached outside
+      # it, or took something in from outside.
+      attr_reader :tainted
+
+      # The timers the drive read or wrote since guard!, as bits: VIA 1's
+      # timer 1 and timer 2 in bits 0 and 1, and VIA 2's in bits 2 and 3.
+      attr_reader :touched_timers
+
       def initialize(rom:, via1:, via2:)
         addressable_at(0, length: 2**16)
         @ram = Memory.new([], length: 0x0800, start: 0)
@@ -47,21 +60,38 @@ module Badline
         @via1 = via1
         @via2 = via2
         @data = 0
-        @watching = false
-        @volatile = false
+        @recording = @guarding = @watching = false
+        @volatile = @tainted = false
         @touched = {}
+        @touched_timers = 0
+        @led = 0
       end
 
       # Starts watching: see volatile and touched. The bus stops watching
       # once the stretch turns volatile.
       def watch!
-        @watching = true
+        @recording = true
         @volatile = false
         @touched = {}
+        watching!
       end
 
       def unwatch!
-        @watching = false
+        @recording = false
+        watching!
+      end
+
+      # Starts guarding: see tainted and touched_timers. Reading VIA 1's
+      # port B, which reads the serial bus, taints the drive, and so do
+      # any write to VIA 1, whose port B drives the serial bus, a write to
+      # VIA 2's shift register or ACR, and VIA 2 turning the motor on or
+      # changing the LED. The bus stops guarding once the drive is tainted.
+      def guard!
+        @guarding = true
+        @tainted = false
+        @touched_timers = 0
+        @led = @via2.port_b_output & Mechanism::LED
+        watching!
       end
 
       def peek(addr)
@@ -86,7 +116,7 @@ module Badline
 
         addr &= 0x1fff
         if addr < 0x0800
-          touch(addr) if @watching
+          touch(addr) if @recording
           @ram.poke(addr, value)
         elsif addr >= 0x1c00
           @via2.poke(addr, value)
@@ -98,36 +128,69 @@ module Badline
 
       private
 
+      def watching!
+        @watching = @recording || @guarding
+      end
+
       def touch(addr)
         @touched[addr] = @ram.peek(addr) unless @touched.key?(addr)
       end
 
       def watch_read(addr)
         if addr < 0x0800
-          touch(addr)
+          touch(addr) if @recording
         elsif addr >= 0x1800
-          watch(addr < 0x1c00 ? VOLATILE_VIA1_READS : VOLATILE_VIA2_READS, addr)
+          via1 = addr < 0x1c00
+          watch(via1 ? VOLATILE_VIA1_READS : VOLATILE_VIA2_READS, addr) if @recording
+          guard_read(via1, addr & 0x0f) if @guarding
         end
       end
 
-      # Any write to VIA 1 makes the stretch volatile, and so does a write
-      # to VIA 2 that leaves the motor on.
       def watch_write(addr)
         if addr >= 0x1c00
-          watch(VOLATILE_VIA2_WRITES, addr)
-          volatile! if @watching && @via2.port_b_output.anybits?(Mechanism::MOTOR)
+          watch_via2_write(addr) if @recording
+          guard_via2_write(addr & 0x0f) if @guarding
         elsif addr >= 0x1800
-          volatile!
+          volatile! if @recording
+          taint! if @guarding
         end
       end
 
+      # Any write to VIA 1 makes the stretch volatile (watch_write), and so
+      # does a write to VIA 2 that leaves the motor on.
+      def watch_via2_write(addr)
+        watch(VOLATILE_VIA2_WRITES, addr)
+        volatile! if @recording && @via2.port_b_output.anybits?(Mechanism::MOTOR)
+      end
+
       def watch(volatile, addr)
         volatile! if volatile.anybits?(1 << (addr & 0x0f))
       end
 
       def volatile!
         @volatile = true
-        @watching = false
+        @recording = false
+        watching!
+      end
+
+      def guard_read(via1, offset)
+        return taint! if via1 && offset.zero?
+
+        @touched_timers |= via1 ? TIMER_REGISTERS[offset] : TIMER_REGISTERS[offset] << 2
+      end
+
+      def guard_via2_write(offset)
+        return taint! if offset.between?(0x0a, 0x0b)
+
+        @touched_timers |= TIMER_REGISTERS[offset] << 2
+        lines = @via2.port_b_output
+        taint! if lines.anybits?(Mechanism::MOTOR) || (lines & Mechanism::LED) != @led
+      end
+
+      def taint!
+        @tainted = true
+        @guarding = false
+        watching!
       end
     end
   end

data/lib/badline/drive1541/idle.rb

@@ -27,7 +27,8 @@ module Badline
     #
     # Such a pass runs the same way again from where it ended, for as
     # long as ATN holds still and no counter sets a flag, so the drive
-    # sleeps: host_cycle! only counts the host cycles that go by. It wakes
+    # sleeps: host_cycle! only counts the host cycles that go by (see
+    # Sleep). It wakes
     # when ATN moves, when a counter is due to set a flag, or when something
     # outside reads or changes the drive (the readers in Drive1541 call
     # settle!). Waking counts off the whole passes it owes in bulk,
@@ -41,6 +42,9 @@ module Badline
     # A pass starts at $EBFF, where the CPU always comes from the loop's
     # last instruction, a JMP, so what that leaves in the CPU's working
     # registers is the same each time round.
+    #
+    # The timer's interrupts come round too, and once they do, the drive
+    # sleeps on through them (see Orbit).
     module Idle
       # Where the DOS 2.6 idle loop starts over.
       IDLE_LOOP = 0xebff
@@ -54,38 +58,15 @@ module Badline
         @idle_skip = on
       end
 
-      # Whether the drive is skipping its idle loop right now.
-      def asleep? = @asleep
-
-      # Brings the drive up to the present, cycle for cycle, and drops the
-      # pass it was recording, since whoever called may change it. Every
-      # reader of the drive's parts calls this.
-      def settle!
-        if @asleep
-          wake!
-          @serial_port.latch_host
-        end
-        stop_recording if @recording
-      end
-
       private
 
-      # A host cycle asleep.
-      def doze
-        @slept += 1
-        settle! if @slept == @wake_at || @serial_port.atn_moved?
-      end
-
       def init_idle(debug)
         @idle_skip = !debug
-        @asleep = false
         @recording = false
-        @owed = 0
-        @budget = 0
-        @slept = 0
-        @wake_at = 0
         @pass_cycles = 0
         @pass_instructions = 0
+        init_sleep
+        init_orbits
       end
 
       # The CPU is at $EBFF. At an instruction boundary, the drive sleeps if
@@ -130,39 +111,10 @@ module Badline
         @pass_cycles = @cycles - @record_cycles
         @pass_instructions = @cpu.instructions - @record_instructions
         @asleep = true
+        @host_still = false
         @owed = 0
         @budget = quiet_cycles
-      end
-
-      # Asleep, host_cycle! counts host cycles, and leaves it to wake! to
-      # turn them into drive cycles through the phase accumulator. This sets
-      # the host cycle that brings the drive cycles owed up to the budget.
-      def plan_wake
-        @slept = 0
-        needed = ((@budget - @owed) * @host_clock_hz) - @phase
-        @wake_at = needed.positive? ? (needed + CLOCK_HZ - 1) / CLOCK_HZ : 1
-      end
-
-      # Runs the cycles owed: whole passes in bulk, up to the budget, and
-      # the rest one by one.
-      def wake!
-        @asleep = false
-        phase = @phase + (@slept * CLOCK_HZ)
-        @phase = phase % @host_clock_hz
-        owed = @owed + (phase / @host_clock_hz)
-        @owed = 0
-        @slept = 0
-        span = [owed, @budget].min
-        passes = span / @pass_cycles
-        if passes.positive?
-          cycles = passes * @pass_cycles
-          @cpu.fast_forward(cycles, passes * @pass_instructions)
-          @via1.fast_forward(cycles)
-          @via2.fast_forward(cycles)
-          @cycles += cycles
-          owed -= cycles
-        end
-        owed.times { step }
+        anchor
       end
 
       def quiet_cycles

data/lib/badline/drive1541/orbit.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    # Sleeping through the DOS's timer interrupts, exactly, once they come
+    # round.
+    #
+    # VIA 2's timer 1 interrupts the idle loop for the job loop, which
+    # finds no job, restarts the timer and returns into the pass it cut
+    # into, 14,998 cycles and more apart. The interrupts land at a
+    # different point in the pass each time, until, six of them on, the
+    # whole drive is back where it was: an orbit of 90,044 cycles.
+    #
+    # Each place the drive falls asleep (see Idle) is an anchor, and the
+    # drive keeps everything it holds at each one: RAM, the counters of
+    # the timers that are armed or that it read or wrote since, and the
+    # rest as Idle compares a pass. It keeps them only while it keeps to
+    # itself, with Bus#guard! checking that it doesn't read the serial
+    # bus, write VIA 1, turn the motor on or change the LED. ATN moving,
+    # or a reader settling the drive, forgets them.
+    #
+    # Coming to an anchor it kept before closes an orbit, which runs the
+    # same way again from here for as long as ATN holds still, so the
+    # drive sleeps on without waking for its counters. Waking counts off
+    # the whole orbits it owes in bulk, moving on only the counters it
+    # never touched, and runs the rest as Idle does.
+    module Orbit
+      # How many anchors the drive keeps while it looks for an orbit.
+      ANCHORS = 32
+
+      private
+
+      def init_orbits
+        @anchors = {}
+        @orbit_cycles = nil
+        @orbit_instructions = 0
+        @bus.guard!
+      end
+
+      # The drive falls asleep at an anchor. One it came to before closes
+      # an orbit: everything from there to here runs the same way again.
+      def anchor
+        forget_orbits if @bus.tainted || @anchors.size >= ANCHORS
+        key = anchor_state
+        if (seen = @anchors[key])
+          @orbit_cycles = @cycles - seen[0]
+          @orbit_instructions = @cpu.instructions - seen[1]
+        else
+          @anchors[key] = [@cycles, @cpu.instructions]
+        end
+      end
+
+      def forget_orbits
+        @anchors.clear
+        @orbit_cycles = nil
+        @bus.guard!
+      end
+
+      # Runs whole orbits, which bring the drive back to the anchor it
+      # sleeps at but for the counters it never touched. Returns the
+      # cycles.
+      def skip_orbits(orbits)
+        cycles = orbits * @orbit_cycles
+        touched = @bus.touched_timers
+        @cpu.fast_forward(cycles, orbits * @orbit_instructions)
+        @via1.skip_orbits(cycles, touched & 0x03)
+        @via2.skip_orbits(cycles, touched >> 2)
+        @cycles += cycles
+        cycles
+      end
+
+      # Everything the drive holds at an anchor, but for the counters of
+      # the unarmed timers it hasn't touched since it was last tainted.
+      def anchor_state
+        touched = @bus.touched_timers
+        [*idle_state, *@via1.counter_state(touched & 0x03), *@via2.counter_state(touched >> 2),
+         @bus.ram.snapshot]
+      end
+    end
+  end
+end

data/lib/badline/drive1541/sleep.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    # The drive asleep, as Idle and Orbit let it: host_cycle! counts the
+    # host cycles that go by, and waking turns them into drive cycles
+    # through the phase accumulator and runs them. Whole orbits and whole
+    # passes go in bulk, and the rest cycle by cycle, which may find the
+    # idle loop and put the drive back to sleep.
+    #
+    # The drive looks at ATN only when the C64 may have moved it, on a
+    # bus that says when (IECBus#notifies?), and every host cycle on one
+    # that doesn't.
+    module Sleep
+      # Whether the drive is skipping its idle loop right now.
+      def asleep? = @asleep
+
+      # Brings the drive up to the present, cycle for cycle, and drops the
+      # pass it was recording and the orbits it found, since whoever called
+      # may change it. Every reader of the drive's parts calls this.
+      def settle!
+        if @asleep
+          wake!
+          @serial_port.latch_host
+          @asleep = false
+          @orbit_cycles = nil
+        end
+        stop_recording if @recording
+        forget_orbits
+      end
+
+      private
+
+      def init_sleep
+        @asleep = false
+        @host_still = false
+        @owed = 0
+        @budget = 0
+        @slept = 0
+        @wake_at = 0
+      end
+
+      # A host cycle asleep that may wake the drive. The bus says whether
+      # the next ones need a look at ATN.
+      def doze
+        @host_still = @serial_bus.notifies?
+        if @serial_port.atn_moved?
+          settle!
+        elsif @slept == @wake_at
+          wake!
+          @serial_port.latch_host
+          plan_wake if @asleep
+        end
+      end
+
+      # Asleep, host_cycle! counts host cycles, and leaves it to wake! to
+      # turn them into drive cycles through the phase accumulator. This sets
+      # the host cycle that brings the drive cycles owed up to the budget.
+      # On an orbit the drive sleeps until something outside wakes it:
+      # @slept counts from 1, so it never comes to 0.
+      def plan_wake
+        @slept = 0
+        return @wake_at = 0 if @orbit_cycles
+
+        needed = ((@budget - @owed) * @host_clock_hz) - @phase
+        @wake_at = needed.positive? ? (needed + CLOCK_HZ - 1) / CLOCK_HZ : 1
+      end
+
+      # Runs the cycles owed.
+      def wake!
+        phase = @phase + (@slept * CLOCK_HZ)
+        @phase = phase % @host_clock_hz
+        owed = @owed + (phase / @host_clock_hz)
+        @owed = 0
+        @slept = 0
+        catch_up(owed)
+      end
+
+      # Runs +owed+ drive cycles: whole orbits and whole passes in bulk,
+      # passes only up to the budget, and the rest cycle by cycle, which
+      # may put the drive back to sleep.
+      def catch_up(owed)
+        while owed.positive?
+          if @asleep
+            if @orbit_cycles && owed >= @orbit_cycles
+              owed -= skip_orbits(owed / @orbit_cycles)
+              next
+            end
+            @orbit_cycles = nil
+            passes = [owed, @budget].min / @pass_cycles
+            if passes.positive?
+              owed -= skip_passes(passes)
+              next
+            end
+            @asleep = false
+          end
+          run_cycle
+          owed -= 1
+        end
+      end
+
+      # Runs whole passes, moving the counters on. Returns the cycles.
+      def skip_passes(passes)
+        cycles = passes * @pass_cycles
+        @cpu.fast_forward(cycles, passes * @pass_instructions)
+        @via1.fast_forward(cycles)
+        @via2.fast_forward(cycles)
+        @cycles += cycles
+        @budget -= cycles
+        cycles
+      end
+    end
+  end
+end

data/lib/badline/drive1541.rb

@@ -7,7 +7,9 @@ require "badline/drive1541/track"
 require "badline/drive1541/disk"
 require "badline/drive1541/mechanism"
 require "badline/drive1541/disk_via"
+require "badline/drive1541/sleep"
 require "badline/drive1541/idle"
+require "badline/drive1541/orbit"
 
 module Badline
   # The 1541 disk drive as a machine of its own: a 6502 running the DOS
@@ -27,9 +29,12 @@ module Badline
   # While the DOS idles, host_cycle! skips the drive's cycles and catches
   # up on them later, exactly (see Idle). The readers of the drive's parts
   # catch up first, so they find the drive as running every cycle would
-  # have left it.
+  # have left it. Once the DOS's timer interrupts come round, the drive
+  # sleeps through them too (see Orbit).
   class Drive1541
+    include Sleep
     include Idle
+    include Orbit
 
     CLOCK_HZ = 1_000_000
 
@@ -143,8 +148,14 @@ module Badline
     # The host has run this cycle already, and the drive sees what it did
     # from the next one on (see SerialPort). Asleep, the drive owes the
     # cycles instead, until ATN moves or its counters are due (see Idle).
+    # It looks at ATN only after the C64 wrote CIA 2's port A, on a bus
+    # that says so (see host_written!).
     def host_cycle!
-      return doze if @asleep
+      if @asleep
+        return if (@slept += 1) != @wake_at && @host_still
+
+        return doze
+      end
 
       phase = @phase + CLOCK_HZ
       while phase >= @host_clock_hz
@@ -157,6 +168,11 @@ module Badline
       plan_wake if @asleep
     end
 
+    # The C64 wrote CIA 2's port A, so ATN may have moved.
+    def host_written!
+      @host_still = false
+    end
+
     # Runs one drive cycle, catching up first on any the drive owes (see
     # step).
     def cycle!

data/lib/badline/iec_bus.rb

@@ -39,8 +39,24 @@ module Badline
     def initialize(host: nil)
       @host = host
       @drives = []
+      @notifies = false
     end
 
+    # Stands in as the host's peripheral, CIA 2's, and has it say when it
+    # writes port A (see notifies?).
+    def plug_in!
+      @host.peripheral = self
+      @host.on_port_a_write { host_written }
+      @notifies = true
+    end
+
+    # Whether the host says when it may have moved a line (see plug_in!).
+    # Without, a drive asleep checks ATN every cycle.
+    def notifies? = @notifies
+
+    # CIA 2 wrote its port A, which may have moved a line.
+    def host_written = @drives.each(&:host_written!)
+
     def attach(drive)
       @drives << drive unless @drives.include?(drive)
     end

data/lib/badline/memory.rb

@@ -22,6 +22,9 @@ module Badline
       (addr...(addr + length)).to_a.map { |a| peek(a) }
     end
 
+    # Every byte, as a copy.
+    def snapshot = @storage.dup
+
     def write(addr, bytes)
       Array(bytes).each_with_index { |b, i| poke(addr + i, b) }
     end

data/lib/badline/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Badline
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/lib/badline/via/fast_forward.rb

@@ -26,6 +26,21 @@ module Badline
         @t2.fast_forward(cycles)
       end
 
+      # The counters an orbit (see Drive1541::Idle) has to bring back: those
+      # of the armed timers, and of the timers +touched+ names (bit 0 for
+      # timer 1, bit 1 for timer 2). The others only count.
+      def counter_state(touched)
+        [(@t1.count_state if @t1.armed? || touched.anybits?(1)),
+         (@t2.count_state if @t2.armed? || touched.anybits?(2))]
+      end
+
+      # Runs +cycles+ cycles of whole orbits at once: the counters
+      # counter_state leaves out move on, and the rest come back round.
+      def skip_orbits(cycles, touched)
+        @t1.fast_forward(cycles) unless @t1.armed? || touched.anybits?(1)
+        @t2.fast_forward(cycles) unless @t2.armed? || touched.anybits?(2)
+      end
+
       # Everything the VIA holds but its counters, for comparing it at two
       # points. Timer 1's PB7 level counts only while ACR bit 7 puts it on
       # the pin: nothing reads it otherwise.

data/lib/badline/via/timer1.rb

@@ -96,6 +96,12 @@ module Badline
       # points.
       def state = [@latch, @armed]
 
+      # Whether a timeout sets the flag.
+      def armed? = @armed
+
+      # The count, for comparing the timer at two points where it matters.
+      def count_state = [@counter, @hold, @reload]
+
       private
 
       # The counter reloads either way. Armed, PB7 inverts and the flag

data/lib/badline/via/timer2.rb

@@ -88,6 +88,12 @@ module Badline
       # comparing the timer at two points.
       def state = [@latch_low, @armed, @hold, @low_reload, @count_pulses, @counting_pulses]
 
+      # Whether the next underflow sets the flag.
+      def armed? = @armed
+
+      # The count, for comparing the timer at two points where it matters.
+      def count_state = [@counter, @low_underflowed]
+
       private
 
       # A cycle while counting pulses, or held after a load or a low byte

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: badline
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Inge Jørgensen
@@ -115,9 +115,11 @@ files:
 - lib/badline/drive1541/gcr.rb
 - lib/badline/drive1541/idle.rb
 - lib/badline/drive1541/mechanism.rb
+- lib/badline/drive1541/orbit.rb
 - lib/badline/drive1541/rotation.rb
 - lib/badline/drive1541/sector_reader.rb
 - lib/badline/drive1541/serial_port.rb
+- lib/badline/drive1541/sleep.rb
 - lib/badline/drive1541/track.rb
 - lib/badline/gui.rb
 - lib/badline/gui/application.rb