Put the frame clock on the 68000, and find that the 12 fps frame does not exist
ROADMAP P3 said "needs MFP timer or VBL" and neither can do it. The MFP's timer clock is 16 MHz/4, its prescalers stop at 200 and its data register is 8 bits, so the slowest tick any single timer can make is 78.125 Hz -- 6.5x faster than a frame -- and 4e6/12 is not an integer, so no setting reaches 12 Hz at all. The raster has no whole divide near 12 either: 4 refreshes is 13.86 fps and 5 is 11.09. tools/analysis/23_frame_clock.py walks all 7x256 timer settings rather than asserting it. src/player/clock.i takes the V-DISP falling edge on MFP GPIP4 -- the start of vertical blanking, which is when a player would present -- and adds fps*VTOTAL per edge to a 16-bit accumulator, emitting a tick at 31,500 and keeping the remainder. The long-run rate is fps*VTOTAL/VTOTAL = 12.000000 fps exactly, and both constants are read out of the CRTC at init, so the clock is derived from the registers that generate the raster it counts. Measured over 3,000 refreshes: 3,000 interrupts, 649 ticks where 649.1429 were due. It costs 181.35 clocks per V-DISP, 838 per frame, 0.1006% of the budget -- timed by the 68000 itself, because the host's granularity is 17.64 ms and the interrupt is microseconds. The loop's own cost was calibrated rather than looked up and landed on 38.000002 clocks, which both licenses the subtraction and confirms buscost.py's model; the 181.35 then decomposes exactly, leaving 43.99 clocks for the interrupt exception -- the textbook 44, measured. THE ONE THAT MOVES SOMETHING: 12 fps on a 55.4577 Hz raster is 4.6215 refreshes, so a frame is shown for 4 refreshes (72.13 ms) or 5 (90.16 ms), 37.9% of them short. The 833,333-clock budget every figure in this project is priced against is the MEAN slot, and the short one is 13.4% under it. The cadence was already in the tree unnamed: stream.lua's tick is sampled at frame boundaries, so its gaps were always 4 or 5, and every host-paced result in FINDINGS 49/51 carried it. P3 moved who produces it onto the machine and made it visible. It is not a dropped frame -- the pace gate lets an overrun eat the next frame's idle -- and on the gate container it costs 4 frames of 120 their idle against 1 for the nominal model, most of that the frame-0 transient at 111% of budget. stream.s counts it now, and the rig matches an offline model of the divider exactly. Also struck: MAME's raster runs 2.22% fast. refresh_mode() builds the frame period from scr.max_x*scr.max_y with scr.max_x = m_htotal - 8, one character cell short and an inclusive bound used as a count, so it runs at 56.6901 Hz where the registers say 55.4577 -- agreeing to six digits with the arithmetic. Every "1/55.46 s granularity" note in this tree was wrong and is 1/56.69 s, corrected in six files with the derivation put once in crtc_mode.lua. No conclusion changes and no 68000 cycle figure moves; the CPU clock is unrelated to the screen. But anything paced by the raster runs fast under MAME, so the rig reports both rates and prices the interrupt against the hardware's. decode.s and frame.i are unchanged; decode.bin is still 1,296 B at the same MD5. The pace gate's wait loop is byte-for-byte the one FINDINGS 51 measured and the free-running path executes none of the new code. check.sh gains two stages: the clock's own measurement, and 120 frames decoded pixel-exact with nothing outside the machine deciding when a frame may start. Claude-Session: https://claude.ai/code/session_01194oWYW8DQXK1SZ2DnChW6
This commit is contained in:
prosolis
+84
-7
@@ -53,7 +53,17 @@
|
||||
-- (FINDINGS 42.1). A default is how a folklore number ends up
|
||||
-- silently underneath a table nobody restates it in.
|
||||
-- DLX_PREFILL_KB bytes to deliver before releasing the CPU (default 0)
|
||||
-- DLX_PACE 1 = hold the decoder to META.fps (default 0 = free-run)
|
||||
-- DLX_PACE 1 = hold the decoder to META.fps, with the HOST writing
|
||||
-- the tick (default 0 = free-run)
|
||||
-- 2 = hold it to META.fps with the 68000 writing its own
|
||||
-- tick, off the CRTC's V-DISP (src/player/clock.i, ROADMAP
|
||||
-- P3). Same gate, same ring, same deadlines; what changes
|
||||
-- is that nothing outside the machine decides when a frame
|
||||
-- may start. Deadlines are then taken from the ticks the
|
||||
-- machine actually emitted rather than from a host model of
|
||||
-- 12 fps -- which matters, because MAME's raster runs 2.22%
|
||||
-- fast (see tools/bench/clock.lua) and a host model would
|
||||
-- quietly grade every arrival against the wrong clock.
|
||||
-- DLX_CUT_AT frame tick at which the pipe stops dead (a seek). Needs
|
||||
-- DLX_PACE; unset = no cut.
|
||||
-- DLX_CUT_FR how many frame times the cut lasts (default 1)
|
||||
@@ -88,7 +98,9 @@ local META = loadfile("stream_meta.lua")()
|
||||
local FLAG, ITER, NFR = 0x18000, 0x18008, 0x1800C
|
||||
local RD_PTR, FR_HEAD, FR_TAIL = 0x18020, 0x18024, 0x18028
|
||||
local STALLS, SPINS, DESC = 0x1802C, 0x18030, 0x18100
|
||||
local PACE, PACEON = 0x18034, 0x18038
|
||||
local PACE, PACEON, CLKON = 0x18034, 0x18038, 0x1803C
|
||||
local CLK_VDISP, CLK_FPS, CLK_ERR = 0x18064, 0x18068, 0x1806C
|
||||
local LATEFR, LATEMAX, LATE1ST = 0x18080, 0x18084, 0x18088
|
||||
local DESCN = 64
|
||||
local CB1, CB4 = 0x20000, 0x22000
|
||||
local RING = 0x40000
|
||||
@@ -108,7 +120,8 @@ if KBPS == nil then
|
||||
return
|
||||
end
|
||||
local PREFILL = (tonumber(os.getenv("DLX_PREFILL_KB") or "") or 0) * 1024
|
||||
local PACED = (os.getenv("DLX_PACE") == "1")
|
||||
local SELFCLK = (os.getenv("DLX_PACE") == "2")
|
||||
local PACED = (os.getenv("DLX_PACE") == "1") or SELFCLK
|
||||
local CUT_AT = tonumber(os.getenv("DLX_CUT_AT") or "")
|
||||
local CUT_FR = tonumber(os.getenv("DLX_CUT_FR") or "") or 1
|
||||
local SLACK_CSV = os.getenv("DLX_SLACK_CSV")
|
||||
@@ -269,9 +282,13 @@ local function setup()
|
||||
SP:write_u32(FLAG, 0); SP:write_u32(FR_HEAD, 0); SP:write_u32(FR_TAIL, 0)
|
||||
SP:write_u32(ITER, 1); SP:write_u32(NFR, META.nframes)
|
||||
SP:write_u32(PACE, 0); SP:write_u32(PACEON, PACED and 1 or 0)
|
||||
SP:write_u32(CLKON, SELFCLK and 1 or 0)
|
||||
SP:write_u32(CLK_FPS, META.fps)
|
||||
P(string.format("stream.bin=%d B, codebooks %d+%d B, disk %d B, %d frames",
|
||||
#code, META.cb1_len, META.cb4_len, META.disk_len, META.nframes))
|
||||
P(string.format("decoder %s%s", PACED and ("PACED at "..META.fps.." fps")
|
||||
P(string.format("decoder %s%s", SELFCLK
|
||||
and ("SELF-PACED at "..META.fps.." fps off V-DISP")
|
||||
or PACED and ("PACED at "..META.fps.." fps by the host")
|
||||
or "FREE-RUNNING (tests wrap, not buffering -- 49.7.2)",
|
||||
CUT_AT and string.format(", pipe cut at tick %d for %.2f fr",
|
||||
CUT_AT, CUT_FR) or ""))
|
||||
@@ -292,6 +309,12 @@ local function launch()
|
||||
end
|
||||
|
||||
local st, t0, t_rel = "boot", nil, 0
|
||||
-- tick_t[i+1] = emulated time of frame tick i, filled in as they are observed.
|
||||
-- Under a self-clock this replaces the host's `t_rel + i/fps` as the deadline:
|
||||
-- the machine's clock is the one the player is actually held to, and MAME's
|
||||
-- raster is 2.22% fast, so grading arrivals against a host model of 12 fps
|
||||
-- would flatter every record by that much.
|
||||
local tick_t = {}
|
||||
local pace, min_ahead, min_at = -1, math.huge, -1
|
||||
local sum_ahead, n_ahead = 0, 0
|
||||
local slack_series = {}
|
||||
@@ -314,10 +337,21 @@ SUB = emu.add_machine_frame_notifier(function()
|
||||
end
|
||||
if st == "running" then
|
||||
if PACED then
|
||||
local tick = math.floor((t - t_rel) * META.fps)
|
||||
-- WHO WRITES THE TICK. Host-paced, the tick is a host model of
|
||||
-- META.fps and this script advances it. Self-paced, the 68000 has
|
||||
-- already advanced it off the raster and this script only READS it --
|
||||
-- the frame gate in src/player/stream.s cannot tell the two apart,
|
||||
-- which is the point: the same bytes are gated either way.
|
||||
local tick = SELFCLK and SP:read_u32(PACE)
|
||||
or math.floor((t - t_rel) * META.fps)
|
||||
if tick > pace then
|
||||
pace = tick
|
||||
SP:write_u32(PACE, pace)
|
||||
if not SELFCLK then SP:write_u32(PACE, pace) end
|
||||
-- The emulated time this tick actually happened, which is what a
|
||||
-- record's deadline is measured against under a self-clock. Ticks
|
||||
-- can arrive more than one apart if the host misses a frame, so the
|
||||
-- whole run is filled rather than just the newest.
|
||||
for k = #tick_t, tick do tick_t[k+1] = t end
|
||||
-- Taken BEFORE this tick's frame is decoded, so snapshot n is the
|
||||
-- finished picture of frame n-1. tick 0 is skipped: nothing has been
|
||||
-- drawn yet and it would record a black screen as a decoded frame.
|
||||
@@ -358,6 +392,14 @@ SUB = emu.add_machine_frame_notifier(function()
|
||||
.."or described wrongly, not that the codec changed.")
|
||||
M:exit(); return
|
||||
end
|
||||
if fl == 0xE2 then
|
||||
local e = SP:read_u32(CLK_ERR)
|
||||
P("FRAME CLOCK REFUSED: CLK_ERR="..e..(e == 1 and
|
||||
" (the CRTC is not in a 31.5 kHz mode, so the divider's 31500 "
|
||||
.."lines/s would be wrong)" or e == 2 and
|
||||
" (fps*VTOTAL does not fit the 16-bit accumulator)" or ""))
|
||||
M:exit(); return
|
||||
end
|
||||
if fl == 0xE1 then
|
||||
P("PRODUCER STALLED OUT -- stream.s spun SPINMAX times with no new "
|
||||
.."record. Delivered "..nsent.."/"..META.nframes..".")
|
||||
@@ -382,6 +424,25 @@ SUB = emu.add_machine_frame_notifier(function()
|
||||
META.nframes, dt, dt*CPUHZ/META.nframes,
|
||||
100*(dt*CPUHZ/META.nframes)/FRAME12, META.fps))
|
||||
end
|
||||
if SELFCLK then
|
||||
-- The clock's own report, in the run where it actually paced a
|
||||
-- decoder rather than a busy loop. The rate is against MAME's fast
|
||||
-- raster; tools/bench/clock_run.sh is where it gets de-skewed.
|
||||
local vd = SP:read_u32(CLK_VDISP)
|
||||
local vt = SP:read_u16(0xE80008) + 1 -- VTOTAL, as clk_init read it
|
||||
-- DELIBERATELY NOT A RATE. 120 ticks is far too short a window to
|
||||
-- quote fps from: the run's start and end each straddle a tick, so
|
||||
-- +/-1 on 119 intervals is +/-8000 ppm and would read as drift the
|
||||
-- clock does not have. What IS exact here is a count of refreshes
|
||||
-- against a count of ticks. The rate figure comes from
|
||||
-- tools/bench/clock_run.sh, over thousands of them.
|
||||
P(string.format("FRAME CLOCK: %d V-DISP interrupts drove %d ticks "
|
||||
.."(%.4f refreshes/frame; the divider's own ratio is "
|
||||
.."31500/(%d*%d) = %.4f), %.0f clocks/frame of "
|
||||
.."interrupt at FINDINGS 54's 181.35 each",
|
||||
vd, pace + 1, vd/(pace + 1), META.fps, vt,
|
||||
31500/(META.fps*vt), 181.35*vd/(pace+1)))
|
||||
end
|
||||
P(string.format("ring: %d wraps, %d B of hole (mean %.1f KB, %.1f%% of "
|
||||
.."the ring)", holes, hole_bytes,
|
||||
holes > 0 and hole_bytes/holes/1024 or 0,
|
||||
@@ -395,6 +456,20 @@ SUB = emu.add_machine_frame_notifier(function()
|
||||
-- opposite thing, so the two are never printed in the same words.
|
||||
P(string.format("UNDERRUNS: %d/%d frames waited past their %d fps slot "
|
||||
.."(%d polls)", stalls, META.nframes, META.fps, spins))
|
||||
-- The other way a paced frame can go wrong, and it is not the same
|
||||
-- failure. An UNDERRUN is the pipe: the record was not there. This
|
||||
-- is the CPU: the record was there, the slot was already open, and
|
||||
-- the decoder had no idle left in the frame before. Under a
|
||||
-- host-written tick every slot is 83.33 ms; under the machine's own
|
||||
-- clock they alternate 72.13 and 90.16 ms, 37.9% of them short, and
|
||||
-- this is what the short ones cost (FINDINGS 54).
|
||||
local late, latemax = SP:read_u32(LATEFR), SP:read_u32(LATEMAX)
|
||||
local late1 = SP:read_u32(LATE1ST)
|
||||
P(string.format("NO IDLE: %d/%d frames found their slot already open "
|
||||
.."-- the frame before used all of it; worst overrun "
|
||||
.."%d whole tick%s, first at frame %d", late,
|
||||
META.nframes, latemax, latemax == 1 and "" or "s",
|
||||
late1 == 0xFFFFFFFF and -1 or late1))
|
||||
-- WHAT THE MINIMUM OVER A RUN IS, AND IS NOT. At release the ring
|
||||
-- holds only what the prefill put there, so the early ticks report a
|
||||
-- buffer that has not been built yet, not a ring or a pipe that
|
||||
@@ -455,7 +530,9 @@ SUB = emu.add_machine_frame_notifier(function()
|
||||
for i = 0, META.nframes-1 do
|
||||
local a = arrival[i+1]
|
||||
if a then
|
||||
local late = a - (t_rel + i / META.fps)
|
||||
local due = SELFCLK and tick_t[i+1] or (t_rel + i / META.fps)
|
||||
if not due then due = t_rel + i / META.fps end
|
||||
local late = a - due
|
||||
if late > 0 then
|
||||
misses = misses + 1
|
||||
if late > worst then worst = late end
|
||||
|
||||
Reference in New Issue
Block a user