1208 lines
78 KiB
Markdown
1208 lines
78 KiB
Markdown
# JoeyLib cross-port performance (UBER benchmark)
|
|
|
|
Regenerated 2026-07-05 (PERF-AUDIT-PLAN.md Phase 8, #25b) from
|
|
same-day captures of all four ports. This supersedes the 2026-07-04
|
|
Phase 0 baseline; every phase of the audit fix plan (0-8) has landed,
|
|
so these are the numbers the library actually ships with.
|
|
|
|
**2026-08-06 update -- Sharp X68000 moved to the 256-colour graphics
|
|
plane.** The port previously drew native-planar into the TEXT plane, which has a
|
|
single 16-entry hardware palette and therefore could not honour the SCB. To make
|
|
SCB per-band palettes work it now presents into the 256-colour GRAPHICS plane
|
|
(`_iocs_crtmod(13)`), expanding the four 1bpp planes to one byte per pixel in
|
|
GVRAM with the DOS port's encoding, `(scb[y] << 4) | nibble`, against the
|
|
256-entry palette at `$E82000`. Storage is UNCHANGED -- still
|
|
`JOEYLIB_NATIVE_PLANAR`; only the present target moved. No raster interrupt is
|
|
involved. All 51 golden hashes are unchanged (jlSurfaceHash hashes the surface
|
|
planes, not GVRAM) and the port stays at 51/51. (The "total wall time is
|
|
identical at 15945 ms" originally written here was an artifact of the broken
|
|
frame clock -- see the clock note at the end of this entry.)
|
|
|
|
Measured 2026-08-06 on the passing 256-colour run with both clocks fixed.
|
|
Honest UBER total wall time is **40890 ms (2249 frames)**. Two earlier figures
|
|
in this entry's history were wrong and are corrected below: 15945 ms came from a
|
|
broken frame clock, and 108309 ms was real but predated the present rewrite.
|
|
|
|
The "pre-LUT" column is the straightforward per-pixel expansion the graphics-plane
|
|
switch first shipped with; "now" is after the word-store expansion tables.
|
|
|
|
| op | pre-LUT | now | IIgs | now / IIgs |
|
|
|---|---|---|---|---|
|
|
| `jlSurfaceClear` | 30 | 106 | 33 | 3.21x |
|
|
| `jlPaletteSet` | 16175 | 58516 | 1561 | 37.49x |
|
|
| `jlScbSetRange` | 5946 | 21206 | 163 | 130.10x |
|
|
| `jlDrawPixel` | 10225 | 36220 | 5576 | 6.50x |
|
|
| `jlDrawLine H` | 2632 | 9370 | 1322 | 7.09x |
|
|
| `jlFillRect 16x16` | 687 | 2414 | 785 | 3.08x |
|
|
| `jlFillRect 80x80` | 84 | 306 | 133 | 2.30x |
|
|
| `jlFillRect 320x200` | 29 | 103 | 22 | 4.68x |
|
|
| `jlDrawCircle r=16` | 165 | 591 | 303 | 1.95x |
|
|
| `jlDrawCircle r=80` | 35 | 125 | 70 | 1.79x |
|
|
| `jlSpriteDraw` | 2059 | 7397 | 1142 | 6.48x |
|
|
| `jlSpriteSaveUnder` | 3570 | 12803 | 602 | 21.27x |
|
|
| `jlTileMapPaste 10x5` | 295 | 1055 | 140 | 7.54x |
|
|
| `jlStagePresent full` | 392 | 1373 | 73 | 18.81x |
|
|
| `gameFrame composite` | 2 | 12 | 12 | 1.00x |
|
|
| `gameFrameClean composite` | 2 | 137 | 20 | 6.85x |
|
|
|
|
**All 39 shared ops now meet or exceed the Apple IIgs reference; median 7.54x,
|
|
slower on none.** The two composite rows are the ones that mattered -- they are
|
|
the closest thing UBER has to a real game frame, and they were the reason the
|
|
port missed the "within ~1.5x of the native ceiling" directive at 0.17x and
|
|
0.10x. `gameFrame composite` is now exactly at parity and `gameFrameClean` is
|
|
6.85x.
|
|
|
|
The fix was NOT a port of DOS's gExpandLut. DOS fuses two ADJACENT output bytes
|
|
into one 16-bit store (mode 13h pixels are neighbouring bytes); here each pixel
|
|
is a 16-bit WORD, so its bytes are two apart and that fusion is impossible.
|
|
Inverting it works: write whole words, and one 32-bit store covers exactly two
|
|
pixels. The high byte is free because the 256-colour index reads only
|
|
`$000F | $00F0` (x68k_v.cpp:339-340). Expansion tables indexed by plane and
|
|
nibble are pre-interleaved into word positions, so four planes OR together with a
|
|
replicated palBase and the inner loop issues four long stores per eight pixels
|
|
with no shifting at all -- against roughly 64 operations and eight byte-stores
|
|
before. Verified three ways, because each layer misses what the others catch:
|
|
51/51 golden (surface correct), a GVRAM dump under PATTERN.X byte-identical to
|
|
the pre-rewrite run (pixel encoding correct), and an earlier framebuffer capture
|
|
(the display actually renders the bands).
|
|
|
|
**Two clock bugs had to be fixed before any of these numbers meant anything, and
|
|
every X68000 figure published before 2026-08-06 was wrong.** The port had no
|
|
`JL_HAS_MILLIS_ELAPSED` override, so milliseconds derived from the frame counter;
|
|
and that counter was POLLED (`vdispPoll`), so an op spanning more than a frame
|
|
lost the V-DISP edges in between. The undercount scaled with the op's cost and
|
|
cancelled it, making every op report ~10,000 ops/sec regardless of workload --
|
|
`jlFillRect 320x200` (9735) matched `jlFillRect 16x16` (10505) despite 250x the
|
|
work. The fix chains Human68k's MFP Timer C, reading its rate from TCDCR/TCDR
|
|
rather than assuming it, and derives the frame counter from that tick.
|
|
`UBER-CLK` now agrees frame-vs-millisecond on every row, which it could not
|
|
before because both figures came from the one broken source.
|
|
|
|
**2026-07-06 update:** the IIgs sprite column is now COMPILED. Finding
|
|
#77 (the loader/segment-BSS + malloc-heap reservation that forced the
|
|
codegen arena into the app's own BSS) was fixed toolchain-side and
|
|
JOEY_IIGS_SPRITE_CODEGEN was re-enabled; the four IIgs sprite rows were
|
|
re-captured (bench-iigs.sh) and jumped 5-25x (SaveUnder 104->543,
|
|
Draw 48->907, RestoreUnder 110->568, SaveAndDraw 15->376 ops/sec),
|
|
bit-identical to the interpreter goldens (diff-uber-hashes 45/45). The
|
|
ST and DOS columns are unchanged from the 2026-07-05 capture.
|
|
|
|
Also 2026-07-06: the Amiga `jlpFillRect` partial-width path was moved
|
|
onto the blitter (BLTAFWM/BLTALWM hardware edge masks + masked minterm),
|
|
which lifted `jlFillRect 16x16` 567->1153, `80x80` 71->269 (both from
|
|
below-floor to well above it), and -- because they build on fillRect --
|
|
`jlDrawLine V` 144->269 and `jlDrawRect 100x100` 122->203, all
|
|
hash-identical (Amiga 45/45). The one remaining Amiga below-floor cell
|
|
is `jlFillCircle r=40` (74%); a whole-circle asm routine was tried and
|
|
did NOT help (per-span dispatch is not the cost -- the 8-way-symmetry
|
|
overlap fill dominates), so it stays on the C span walker for now.
|
|
|
|
**2026-07-06, NATIVE-PERF Phase 0:** four WORKLOAD rows were added (see
|
|
NATIVE-PERF-PLAN.md) and the goldens refrozen at **49 lines** after a
|
|
clean regression gate (45 match + exactly 4 extras per port) and full
|
|
4-port cross-identity. The new rows measure what games actually do, and
|
|
they expose the real problem the per-op rows hid: `jlSpriteDraw
|
|
unaligned` runs at **5% (ST) / 9% (Amiga)** of the IIgs floor -- a
|
|
15x/12x cliff vs the aligned row, because only x%8==0 draws are
|
|
compiled on the 68k ports (see the plan's code-truth table). The
|
|
`gameFrame composite` row is the bottom line: **ST 9 / Amiga 18 /
|
|
IIgs 10 / DOS 18 frames/sec** for a modest game frame. Bonus finding:
|
|
cross-identity of the sweep16 row validated the ST/Amiga shifted c2p
|
|
walkers as pixel-perfect at all 14 previously-untested x phases.
|
|
(Re-capture note: IIgs input/audio rows wobbled vs the prior MAME run
|
|
-- e.g. jlAudioFrameTick 50223 -> 27612 -- run-to-run MAME variance on
|
|
cheap ops; hashes are unaffected and those rows gate nothing.)
|
|
|
|
**2026-07-06, NATIVE-PERF Phase 1 (draw side) LANDED:** all-shift
|
|
compiled sprite DRAW on both 68k ports. Amiga emits pre-shifted JIT
|
|
variants for all 8 bit phases; the ST emits per-phase thunk + data
|
|
tables driven by a shared masked-movem walker (spriteWalk.s) for all
|
|
16 intra-group phases, with the dispatcher's ST shift contract changed
|
|
to x & 15. jlSpriteCompile is now plan-based: it measures every
|
|
(shift, op) variant, greedily fits them under the uint16 offset cap
|
|
(draws first, save/restore as atomic pairs), and degrades to the
|
|
byte-aligned phases when the arena is too small instead of losing the
|
|
sprite. RESULT -- the alignment cliff is CLOSED: `jlSpriteDraw
|
|
unaligned` ST 40 -> 500 ops/sec (12.5x), Amiga 75 -> 803 (10.7x);
|
|
sweep16 ST 2 -> 32 sweeps/sec (512 draws/sec), Amiga 5 -> 50 (800
|
|
draws/sec). Unaligned now performs like aligned on both ports (ST 82% /
|
|
Amiga 84% of their aligned rows), and every one of the 49 golden
|
|
hashes still matches -- the compiled paths are bit-identical to the
|
|
interpreted walkers they replace, on all four ports. (Found along the
|
|
way: the Amiga bench task stack was ~4 KB -- one deep call chain from
|
|
overflow -- now 32 KB in bench-amiga.sh; the emitters' accumulators are
|
|
file statics.)
|
|
|
|
**Phase 1 step 5 (save/restore) ALSO LANDED, completing Phase 1:**
|
|
compiled save/restore on both 68k ports operate on the 16-px-group
|
|
window (two width classes per sprite, like the IIgs MVN pair), the
|
|
backup format is a pure function of the recorded geometry (identical
|
|
for compiled and interpreted producers/consumers -- the ST HAL gained a
|
|
raw-span interpreted branch, switched atomically with restore), and the
|
|
gates route by SPRITE_SAVE_CLASS / SPRITE_RESTORE_CLASS with an odd-
|
|
buffer-pointer demotion (68000 word ops need even addresses). The
|
|
combined jlSpriteSaveAndDraw path now fires on 68k at EVERY x for the
|
|
first time. RESULTS (floor-relative): Amiga SaveUnder 104% -> 276%,
|
|
RestoreUnder 98% -> 236%, SaveAndDraw 94% -> 160%; ST SaveUnder
|
|
158% -> 203%, RestoreUnder 122% -> 163%, SaveAndDraw 87% -> 107%;
|
|
Amiga gameFrame 18 -> 23 fps. Backup capacity contract:
|
|
JOEY_SPRITE_BACKUP_BYTES in sprite.h (window worst case; all in-repo
|
|
examples migrated + 2-aligned). DEFAULT_CODEGEN_BYTES is 64 KB on
|
|
Amiga/ST (full variant sets). All 49 golden hashes held throughout.
|
|
|
|
**2026-07-07, THE ST COLUMN DOUBLED -- idle-audio ISR tax found and
|
|
fixed:** every previous ST capture ran with ~49.5% of the CPU silently
|
|
consumed by the 12.3 kHz Timer-A PWM ISR that jlpAudioInit started
|
|
unconditionally -- it streamed buffer silence to the YM even with
|
|
nothing playing, and UBER inits audio before its timed run. Found by
|
|
a calibrated probe (known-cycle dbra spin + per-layer direct-call rows
|
|
under the bench Hatari config): every probe row slowed by exactly
|
|
1.98x once audio was initialized, and the probe's un-taxed tilePaste
|
|
cycles/call matched the instruction-count model that UBER's number
|
|
mysteriously doubled. Fix: src/atarist/audio.c Timer A is now
|
|
demand-driven -- installed on the first PlayMod/PlaySfx, parked again
|
|
once the mix buffer drains back to silence with nothing live
|
|
(drain-to-silence handshake in jlpAudioFrameTick; StopMod parks
|
|
immediately when no SFX is riding the pump). Probe-verified: idle rows
|
|
match the never-initialized rows exactly, the tax correctly returns
|
|
while an SFX drains, and it vanishes after the drain. Full ST
|
|
re-bench: 49/49 hashes bit-identical (pixels untouched) and EVERY row
|
|
~2x: gameFrame 9 -> 19 fps, tilePaste 1,574 -> 3,203/s, sprite draw
|
|
607 -> 1,188/s, unaligned draw 508 -> 992/s. The other three ports
|
|
were audited for the same bug class and are clean: Amiga ~1.8% idle
|
|
tax (PTPlayer rides Paula DMA), DOS ~0.5% (SB auto-init DMA, ~11 Hz
|
|
half-buffer IRQ), IIgs 0% (no handler installed until PlayMod). ALL
|
|
pre-2026-07-07 ST comparisons -- including the Phase-0 ceiling gaps
|
|
and the Phase-1 relative results -- understated the ST by ~2x.
|
|
|
|
**2026-07-07, NATIVE-PERF PHASE 4 (IIgs arm) LANDED -- whole-map asm
|
|
walker:** iigsTileMapPasteMark (joeyDraw.s) replaces the IIgs
|
|
stage-arm per-tile loop of jlTileMapPaste with ONE JSL that walks the
|
|
index map: dst offset advances incrementally (+4/column, +1280/tile
|
|
row) from a single gRowOffsetLut read, the register-starved inner
|
|
lives in a 22-byte stacked D-frame (X survives the 16-store body and
|
|
carries the dst offset; the map index sits in the frame because Y is
|
|
clobbered), the idx << 5 tileset add carries into the bank byte, all
|
|
three wrapping branches are brl, and ONE band union closes the call.
|
|
Gated 50/50 + make iigs-verify. RESULT: IIgs batch row 60 -> 140
|
|
maps/s = 7,000 tiles/s (+133%), ~400 cyc/tile -- BELOW the 480-cyc
|
|
single-tile hand-coded ceiling, because the walker amortizes the
|
|
JSL/derive/mark that even a hand-coded per-tile call pays. Batch row
|
|
across all ports: ST 8,150 / Amiga 7,650 / IIgs 7,000 / DOS 22,500
|
|
tiles/sec (the morning's per-call loop numbers were 1,600 / 2,300 /
|
|
1,750 / 10,000). The Amiga blitter cookie-cut sprite was recon'd and
|
|
DEFERRED with a full design on record: the synchronous WaitBlit the
|
|
hash contract requires erases the parallelism win at <= 16x16 (every
|
|
current sprite row), and the chip-RAM pre-shifted source data is a
|
|
net-new subsystem -- the honest experiment is a >= 32x32 golden'd row
|
|
measured with and without the fence.
|
|
|
|
**2026-07-07, NATIVE-PERF PHASE 4 CLOSED -- clean-buffer experiment
|
|
PASSED, jlSurfaceCopyRect is public API:** Scott signed off the
|
|
jlTileMapPaste shape and approved the clean-buffer experiment; both
|
|
landed same-day. jlSurfaceCopyRect(dst, src, x, y, w, h) is a
|
|
SAME-POSITION rect copy (clip, then snap outward to the 16-px group
|
|
grid on every port -- uniform snap keeps cross-port hashes
|
|
byte-identical): core wrapper + dirty mark in surface.c, generic
|
|
chunky row-memcpy engine (serves DOS and both IIgs surface flavors --
|
|
the IIgs stage pixels pointer reaches bank $01 through ordinary
|
|
large-model stores, recon-verified against the sprite-restore
|
|
precedent), ST override = strided interleaved row memcpys (the
|
|
raw-span restore recipe), Amiga override = per-plane CPU row copies
|
|
(CopyMemQuick is unusable at 16-px grain: word alignment only;
|
|
the modulo-driven blitter variant is the recorded production
|
|
upgrade). The STRATEGY row `gameFrameClean composite` (erase 3
|
|
sprite windows from a pristine clean surface + 3 draws + present; NO
|
|
per-frame background repaint, NO save-under -- the static-background
|
|
pattern, not an op-for-op gameFrame speedup) measures, vs gameFrame:
|
|
**ST 48 vs 22 = 2.18x (acceptance bar was 1.4x), DOS 195 vs 19 =
|
|
10.3x, IIgs 18 vs 10 = 1.8x, Amiga 34 vs 25 = 1.36x** (Amiga gains
|
|
least, exactly as the adversarial recon predicted: its fillRect was
|
|
already blitter-fast, and clean->stage is a chip-to-chip CPU copy
|
|
against display DMA -- the blitter rect variant is its lever).
|
|
GOLDEN CONTRACT now **51 lines**: regression gate exactly 50 match +
|
|
1 extra per port, 4-port cross-identity of the new row (hash
|
|
C51FE171 x4), then freeze. Found along the way: `make all` does NOT
|
|
regenerate joey.2mg, so bench-iigs.sh silently benched the previous
|
|
UBER (clean 50/50, new row absent) until `make iigs-disk` -- recorded
|
|
in the stale-binary memory.
|
|
|
|
**2026-07-07, NATIVE-PERF PHASE 4 (ST arm) LANDED -- movep.l map
|
|
engine:** the ST jlTileMapPaste arm now dispatches to
|
|
stTileMapPasteMovep (src/atarist/tileMap.s): per tile row, one
|
|
`move.l (a0)+` + `movep.l d0,d16(a1)` writes all 4 interleaved plane
|
|
bytes in 36 cycles vs ~80 for the four compiled move.b -- movep IS
|
|
the half-group byte-scatter pattern (the classic ST c2p trick), where
|
|
movem is useless (byte-granular dst) and byte-pair word fusion loses
|
|
(lsl.w #8 costs 22 cyc on a barrel-shifterless 68000, priced during
|
|
recon). Cells walk in even/odd pairs sharing one group pointer
|
|
(+8/pair, all row offsets compile-time d16); odd bx = head cell, odd
|
|
width = tail cell. The C pair walker (stTileMapPaste in stTile.h,
|
|
+17% alone -- adversarial recon correctly predicted the pure-C cap at
|
|
+15-23% because gcc already hoists the mulu and the 632-cyc copy body
|
|
dominates) stays as the odd-tileset-pointer fallback: `move.l (a0)+`
|
|
needs an even source, jlTileT is align-1, and the guard is one AND
|
|
per call. RESULT: ST batch row 163 -> 346 ops/sec = **17,300
|
|
tiles/s** (2.12x, 462 cyc/tile) -- ABOVE the Phase-0 12,700-15,500
|
|
"hand-coded ceiling", which under-counted by assuming byte-move
|
|
bodies. Gate: ST 50/50 bit-identical (hash 52B9646B held through
|
|
both engines) + a 12-case on-emulator proof (TILETEST, session
|
|
scratchpad) covering odd-bx head, odd-width tail, w=1 columns, h=1,
|
|
checkerboard/end/all skips, and both odd-pointer fallback paths,
|
|
each with a border-ring containment check. Batch row across ports:
|
|
DOS 22,500 / ST 17,300 / Amiga 7,650 / IIgs 7,000 tiles/s. IIgs
|
|
PEI-slam map variant was EVALUATED and REJECTED: models ~+28%
|
|
(~312 cyc/tile) but requires SEI for the whole map (~5.6 ms
|
|
interrupts-off at 10x5, audio ISR jitter) AND the VBL-driven bench
|
|
clock cannot honestly measure SEI ops (PERF artifact: SEI inflation)
|
|
-- the walker already beats the 480-cyc per-tile ceiling without it.
|
|
|
|
**2026-07-07, NATIVE-PERF PHASE 3 LANDED -- jlTileMapPaste batch API:**
|
|
one public entry pastes a wTiles x hTiles rectangle from a tileset +
|
|
row-major uint8_t index map (TILE_MAP_SKIP = 0xFF leaves a cell
|
|
untouched): one validation, one dirty union (68k/DOS; the IIgs
|
|
stage-fused entries mark per pasted tile, and its loop hoists the
|
|
stage test + does tileset indexing as base + (idx << 5) -- the
|
|
natural tiles[idx] spelling cost a 32-bit indexed multiply per cell
|
|
on the 65816 and erased the batch win until specialized). GOLDEN
|
|
CONTRACT now **50 lines**: refreeze followed the Phase-0 procedure
|
|
(regression exactly 49 match + 1 extra per port, then 4-port
|
|
cross-identity of the new `jlTileMapPaste 10x5` row -- all four hash
|
|
52B9646B -- then freeze). RESULTS, tiles/sec batch vs per-call loop:
|
|
ST 8,150 vs 4,000 (+106%, gap-to-ceiling 1.6-1.9x); Amiga 7,650 vs
|
|
3,750 (+104%, gap 1.40x -- INSIDE the ~1.5x program target); DOS
|
|
22,500 vs 12,900 (+74%, 2.5x); IIgs 3,000 vs 2,950 (+2% -- its
|
|
Phase-2 fused entries already deleted the per-tile wrapper, so the
|
|
remaining cost is ~93% inner JSL; a whole-map IIgs asm walker is the
|
|
Phase-4 lever). Sprite batch APIs were DESCOPED from Phase 3: the
|
|
phase gate measures only the tilemap row, and post-R5 sprite dispatch
|
|
overhead is ~3-6% -- not worth new public surface without a measured
|
|
need.
|
|
|
|
**2026-07-07, NATIVE-PERF PHASE 2 COMPLETE -- Steps D3 (R6 + R10)
|
|
close the phase:** (R6) the IIgs masked-copy inner's 4 x 8 jsr/rts
|
|
round-trips to tmaskByte were inlined via the TMASK_BYTE assembler
|
|
macro (identical body; the row loop-back became brl -- the expanded
|
|
body exceeds 8-bit branch range): jlTileCopyMasked 625 -> 681 (+9%,
|
|
exactly the 384-cycle model). (R10) the stage arm of jlDrawPixel is
|
|
one fused JSL (iigsDrawPixelMark: single-row widen + nibble RMW plot
|
|
against the pinned stage base): jlDrawPixel 3,179 -> 5,576 (+75%, 502
|
|
cyc/call incl. wrapper vs the measured 880 before); the batching
|
|
plotters (lines/circles, plotPixelNoMark) keep the unfused inner and
|
|
were flat, as were tiles/sprites. Final gate 49/49 x4 + make
|
|
iigs-verify. PHASE-2 EXIT vs its gate ("small-op rows move measurably
|
|
toward Phase-0 ceilings on all ports; goldens hold"): tilemap row
|
|
tiles/sec ST 1,600 -> 4,050 / Amiga 2,300 -> 3,750 / IIgs 1,750 ->
|
|
2,950 / DOS 10,000 -> 12,900; gameFrame ST 9 -> 21 / Amiga 18 -> 25 /
|
|
IIgs 10 / DOS 18 -> 19; IIgs tilePaste ceiling gap 3.5x -> 2.15x, ST
|
|
2.6x. The remaining per-call floor is the public wrapper + one
|
|
JSL/call -- Phase 3 batching territory. Optional leftovers R7
|
|
(saveAndDraw consolidation) and R12 (IIgs C-residue reshapes) are
|
|
recorded in the plan, not phase-gating.
|
|
|
|
**2026-07-07, NATIVE-PERF Phase 2 Step D2 LANDED -- sprite dispatch
|
|
flattening (R5):** the spriteCompiled* runtime dispatchers moved from
|
|
spriteCompile.c into spriteDispatch.h as always-inline functions
|
|
consumed only by sprite.c, deleting the cross-TU call per compiled
|
|
sprite op and letting the compiler share the slot/field loads the
|
|
caller already did. Gated 49/49 x4. Sprite rows: IIgs +6-13%
|
|
(SaveAndDraw 376 -> 423, Draw 906 -> 966), ST SaveUnder +15% (2,611),
|
|
Amiga +5-11% (SaveUnder 2,053), DOS SaveUnder +16% (10,743). Two
|
|
measurement footnotes: gameFrame wobbles +/-1 fps between runs
|
|
(single-digit iters per 16-frame window -- quantization, not signal;
|
|
ST has bounced 21/22 across three consecutive gates), and DOS
|
|
`jlSpriteDraw unaligned` is BIMODAL across runs of identical binaries
|
|
(~3,800 vs ~5,100; seen 07-06 and again today; the all-phase sweep16
|
|
row is stable at ~362, so per-phase behavior is fine -- likely DOSBox
|
|
dynamic-core state; do not chase single-run deltas on that row).
|
|
|
|
**2026-07-07, NATIVE-PERF Phase 2 Step D1 LANDED -- IIgs fused tile
|
|
entries (R2):** jlTileFill/Copy/Paste on the stage now run ONE JSL
|
|
each: new joeyDraw.s entries (iigsTile*Mark, section
|
|
.text.iigsFusedTile) derive the destination in asm from the pinned
|
|
$01:2000 stage base + gRowOffsetLut, write via long,X with the stage
|
|
literal folded into each store, and widen the dirty band via a shared
|
|
stageTileMark helper -- replacing C-side pointer math plus two JSLs
|
|
(op + marker). Gated 49/49 (pixels) AND make iigs-verify (framebuffer
|
|
-- the mark half is hash-blind, so the display check is load-bearing).
|
|
RESULTS: IIgs tileFill 1,981 -> 3,251 (+64%), tilePaste 1,687 -> 2,710
|
|
(+61%), tileCopy 1,441 -> 1,988 (+38%), map row 35 -> 59 (+69% = 2,950
|
|
tiles/s), gameFrame 10 -> 11 fps; unfused controls (copyMasked, snap,
|
|
sprites) flat. IIgs tilePaste is now ~1,030 cyc/call vs the 480-cyc
|
|
hand-coded ceiling (gap 2.15x, was 3.5x). Toolchain landmine found en
|
|
route: a 16-bit jsr between .section blocks can cross OMF segment
|
|
banks (no link error, wild jump into $00CFxx) -- helpers must share
|
|
their callers' section or be jsl/rtl; see the cross-section-jsr
|
|
feedback memory.
|
|
|
|
**2026-07-07, NATIVE-PERF Phase 2 Steps A-E LANDED (per-op tax):**
|
|
five hash-gated steps, each 49/49 x4. (A) plane-pointer access
|
|
inlined into the 68k compiled-sprite dispatchers (amigaPlanar.h /
|
|
stPlanar.h; the jlpSurfacePlanePtr cross-TU call -- ~190 cyc x4 per
|
|
Amiga dispatch -- deleted): Amiga sprite ops +10-23%. (B) whole-tile
|
|
dirty marks specialized (band = [bx*2, bx*2+1] with compile-time
|
|
proof, unrolled 8-row widen): tiles +9-28% on 68k/DOS. (C) jlDrawRect
|
|
raw-edge fills + ONE band-identical mark (+22-40%); the multi-row
|
|
widen unroll is Amiga-only by measurement (gcc-mint compiled it WORSE,
|
|
ST -5% -- see the per-port #if in surface.c). (D=R9) presents consume
|
|
the core gStageScbDirty/gStagePaletteDirty flags instead of
|
|
memcmp'ing 512-712-byte cached mirrors: gameFrame +1-2 fps on
|
|
ST/Amiga/DOS. (E) ST/Amiga tile ops moved into always-inline per-port
|
|
headers (stTile.h / amigaTile.h), deleting the second cdecl layer
|
|
(ST tiles +9-14%, Amiga +5-11%), then the Amiga row loops unrolled to
|
|
d16(An) form (tilePaste +36%, tileSnap +52%). NET SESSION MOVEMENT on
|
|
the tile gate row (tiles/sec, map 10x5): ST 1,600 -> 4,000; Amiga
|
|
2,300 -> 3,750; DOS 10,000 -> 12,900. gameFrame: ST 9 -> 21, Amiga
|
|
23 -> 25, DOS 18 -> 19 fps (IIgs untouched at 10 -- its fused-asm
|
|
glue is Phase 2 Step D, still open). The present-row jumps (ST 467,
|
|
DOS 1,137) are the dirty-union idle early-out running flag-gated;
|
|
gameFrame is the honest present signal.
|
|
|
|
Correctness statement backing this table: all FIVE ports produce
|
|
BYTE-IDENTICAL pixels on every measured op and every correctness
|
|
check -- **51/51** surface hashes match the frozen goldens in
|
|
tests/goldens/uber/ (39 timed ops + 12 hashed checks; the X68000 has no
|
|
golden of its own and is diffed straight against iigs.txt; the PASS/FAIL
|
|
checks -- palette round-trip, PRNG golden sequence, sprite clip
|
|
round-trip, arena churn, sprite-from-surface -- pass everywhere).
|
|
The Phase 0-era divergences (#75 tilePasteMono three-way, #78 ST
|
|
fillCircle/tileFill, #87 IIgs circle outline) are all fixed.
|
|
|
|
**2026-07-09, Phase 7 P7-3 -- Amiga present sped up (src/amiga/hal.c
|
|
only).** The Amiga present was Phase 6's single largest out-of-bar item
|
|
(2.8-5.3x). A probe forensic split it: a fixed per-present scan (P8 idle
|
|
= 1.51 ms) plus, for large presents, a ~11 ms CPU copy (P1 present96
|
|
copied 12,288 B). Two bisectable changes, each P11-gated (presentPageSum
|
|
= exhaustive displayed-page-vs-shadow byte parity, the gate for the
|
|
hash-invisible present -- PASS on both): (A) the per-present snapshot
|
|
pass was folded into the scan's COLD union-dirty path (a row clean in
|
|
both frames already holds the clean sentinel in gPrev, so the hot path
|
|
stays 2 loads -- a first attempt that touched every row REGRESSED and
|
|
re-confirmed the recorded gcc-amigaos register-pressure trap), dropping
|
|
the present from two 200-row passes to one (scanned 400 -> 200); (B) the
|
|
large-run copy now runs on the blitter via the W3 amigaBlitterCopyPlanes
|
|
(A->D, offset+modulo) above a 128-plane-word threshold, so present96 /
|
|
gameFrame's 96-row bands move off the CPU while present3win's scattered
|
|
windows stay on the CPU THIN path. RESULTS: present96 46 -> 71 (+54%),
|
|
present3win 93 -> 103 (+11%), gameFrame 25 -> 31 (+28%), gameFrameClean
|
|
62 -> 71, jlStagePresent full 584 -> 609; Amiga 51/51 golden hashes hold
|
|
(present changes are hash-invisible -- pixels unchanged). Remaining
|
|
Amiga-present lever: a fused-scan present asm (ST presentSlam analogue
|
|
over 4 plane buffers) for the scan-bound rows -- C fusion is now
|
|
empirically register-pressure-capped, and the async-fence blitter
|
|
contract stays parked behind a >=32x32 row.
|
|
|
|
**2026-07-09 -- fused-scan present asm + a component probe that located
|
|
the real cost.** src/amiga/presentScan.s (hand-rolled 68000, the 4 band
|
|
arrays walked in address registers) replaces jlpPresent's C union scan.
|
|
The plain asm (no fast path) barely moved present3win (103->106), which
|
|
first read as "the scan isn't the bottleneck" -- but a present-component
|
|
skip-mask probe corrected that. It split present3win's 9.4 ms: SCAN
|
|
~4.9 ms, FLUSH ~3.3 ms (chip->chip CPU copy of the 3 tiny windows), FLIP
|
|
~0.4 ms, residual (copper-check/reset/WaitBlit/marks/harness) ~1.2 ms;
|
|
the 3 marks alone are 0.64 ms. So the scan IS ~half the present -- the
|
|
plain asm just wasn't faster than gcc because the scan is
|
|
INSTRUCTION-COUNT-bound (~16 instr x 200 rows), not the register spill it
|
|
was assumed to be. The ST presentSlam 4-row fast path (one move.l
|
|
compares 4 clean-sentinel min bytes, cur AND prev, and skips the group;
|
|
needs gPrev arrays aligned(2)) LANDED: present3win 106->128 (+21%),
|
|
present96 ->78, gameFrame 32->34, gameFrameClean 62->82, P11 PASS, 51/51.
|
|
A first cut passed all PIXEL gates but broke the gameFrameClean golden
|
|
row -- a bisect proved the fast path's 'bra .rowLoop' skipped the
|
|
loop-exit check, so a clean group ending at row 199 landed the row index
|
|
on 200 and processed a PHANTOM out-of-bounds row 200 (writing
|
|
gPrevStageMin/MaxWord[200] one byte past the arrays). That corrupts a
|
|
neighbouring global invisibly to P11/hashes/counters yet breaks a later
|
|
jlSurfaceCreate AllocMem -- gameFrameClean (the only op allocating a 2nd
|
|
surface) was an accidental memory-integrity canary. FIX: the exit check
|
|
now lives at the TOP of .rowLoop, guarding both re-entry paths. The FLUSH
|
|
lever also LANDED: the ~3.3 ms chip->chip CPU copy of the small windows
|
|
was contention-bound, so lowering AMIGA_PRESENT_BLIT_MIN_WORDS 128 -> 16
|
|
routes them to the blitter (parallel chip->chip DMA) -- present3win
|
|
128 -> 153 (+20%), gameFrameClean 82 -> 90, 51/51 + P11. An OWN-ONCE
|
|
flush polish (the present OwnBlitters once instead of per window) also
|
|
landed correct (51/51 + P11) but PERF-FLAT (present3win 153 -> 154,
|
|
within noise): after the threshold drop the flush is blitter-DMA-bound,
|
|
so the per-window Own/Disown it removes was already negligible -- kept
|
|
for the right blitter discipline, not a speedup. Session present3win arc
|
|
106 -> 128 -> 153 -> 154 = +45%. No known remaining flush lever.
|
|
|
|
**2026-08-05, FIFTH PORT: Sharp X68000 -- the hashes PASS, the clock
|
|
does NOT.** src/x68000 + make/x68000.mk (JOEYLIB_PLATFORM_X68000) is on
|
|
the golden gate: tools/diff-uber-hashes reports OK: 51/51 ops match. The
|
|
port carries NO frozen golden of its own -- it is diffed straight
|
|
against tests/goldens/uber/iigs.txt, which it matches exactly. Shape:
|
|
10 MHz 68000, NATIVE PLANAR storage (4 x 1bpp planes, 40 bytes/row,
|
|
X68K_PLANE_SIZE 8,000), byte-for-byte the Amiga surface layout -- but
|
|
the DISPLAY is not the surface. It draws into the TEXT plane (four 1bpp
|
|
planes at $E00000/$E20000/$E40000/$E60000, 128-byte stride), NOT
|
|
graphics VRAM, so jlpPresent scatters the compact 40-byte rows into that
|
|
stride: 32,000 bytes/frame against 128,000 bytes of GVRAM word writes on
|
|
the chunky path it replaced (src/x68000/x68kPlanar.h:20-33). The 320x200
|
|
window is CENTRED in a 512x512 mode (_iocs_crtmod 12) at x=96 / y=156,
|
|
byte-aligned by construction (96/8 = 12). Palette is the 16-entry
|
|
PCG/text palette at $E82200 -- NOT the $E82000 graphic palette -- in
|
|
GGGGGRRRRRBBBBBI order, green and red SWAPPED versus RGB555 plus ONE
|
|
SHARED intensity LSB; and because the text plane has exactly one
|
|
16-entry palette, per-scanline SCB palettes cannot be honoured (palette
|
|
0 always wins) -- unlike the ST, which really does emulate per-band SCB
|
|
palettes from an MFP Timer B ISR, so this port stands alone in ignoring
|
|
the SCB on screen. [SUPERSEDED 2026-08-06: the port moved to the
|
|
256-colour graphics plane (_iocs_crtmod 13, palette $E82000) precisely to
|
|
fix this -- SCB per-band palettes now work, DOS-style. See the
|
|
2026-08-06 entry at the top. The rest of this paragraph still describes
|
|
the port accurately.] Sprites COMPILE (shared 68k planar emitter, see the
|
|
Reading notes). Toolchain is elf2x68k at toolchains/x68000/m68k-xelf
|
|
(gcc 13.4.0, ELF -- so no leading-underscore asm symbols, and
|
|
src/m68k/*.s does not link there); disks are built by tools/xdftool.py
|
|
(Human68k FAT12, 1024-byte sectors, .X executables); the emulator is a
|
|
patched MAME 0.264 single-driver build (patches/mame-0.264-x68k-*.patch).
|
|
The only recorded rate-card input so far is from those patches: TVRAM
|
|
costs ~1.92 extra cycles/access and GVRAM ~1.03 versus main memory,
|
|
applied only at a 10 MHz CPU clock (docs/x68000_mame_crtc_timing.md:307-309,
|
|
328) -- which is why the 4x traffic cut to the text plane wins despite
|
|
TVRAM's higher per-access cost. NO ceilings are derived for this port
|
|
anywhere in this file, and none should be until the clock is fixed.
|
|
|
|
THE COLUMN BELOW IS NOT COMPARABLE TO THE OTHER FOUR. It is recorded raw
|
|
because the capture is expensive and the log is not kept in-tree, not
|
|
because the numbers mean what they say -- see measurement artifact 5.
|
|
Capture route: UBER built with the serial log tee
|
|
(EXTRA_CFLAGS=-DJOEY_LOG_SERIAL_TEE, which now reaches every port via
|
|
make/common.mk:26; src/core/debug.c calls jlpLogTee, implemented at
|
|
src/x68000/hal.c:353) against scripts/x68kSerialPeer.py, which MUST be
|
|
run as `python3 -u` or a killed peer loses the whole capture to stdio
|
|
buffering. This is the only route that gets a full log off the machine:
|
|
the disk route (scripts/verify-x68000-golden.sh) forces -DUBER_FRAMES=1u
|
|
and cannot produce timings at all -- and in practice cannot produce the
|
|
log either, because joeylog.txt never commits its size to the Human68k
|
|
image. Run header as reported: total wall time 15,945 ms, 877 frames
|
|
@ 55 Hz (both from the suspect clock).
|
|
|
|
| Op | X68000 (reported ops/sec) |
|
|
| --- | --- |
|
|
| jlSurfaceClear | 8775 |
|
|
| jlPaletteSet | 14353 |
|
|
| jlScbSetRange | 8305 |
|
|
| jlDrawPixel | 8580 |
|
|
| jlDrawLine H | 8855 |
|
|
| jlDrawLine V | 8800 |
|
|
| jlDrawLine diag | 8195 |
|
|
| jlDrawRect 100x100 | 8470 |
|
|
| jlDrawCircle r=16 | 8305 |
|
|
| jlDrawCircle r=80 | 7316 |
|
|
| jlFillRect 16x16 | 9295 |
|
|
| jlFillRect 80x80 | 22182 |
|
|
| jlFillRect 320x200 | 6986 |
|
|
| jlFillCircle r=40 | 9240 |
|
|
| jlSamplePixel | 10395 |
|
|
| jlTileFill | 8195 |
|
|
| jlTileCopy | 8525 |
|
|
| jlTileCopyMasked | 8745 |
|
|
| jlTilePaste | 9405 |
|
|
| jlTileSnap | 8690 |
|
|
| jlSpriteSaveUnder | 8580 |
|
|
| jlSpriteDraw | 8250 |
|
|
| jlSpriteRestoreUnder | 8886 |
|
|
| jlSpriteSaveAndDraw | 8305 |
|
|
| jlStagePresent full | 572 |
|
|
| jlInputPoll | 8250 |
|
|
| jlKeyDown | 53006 |
|
|
| jlKeyPressed | 53611 |
|
|
| jlMouseX | 125529 |
|
|
| joeyJoyConnected | 53006 |
|
|
| jlAudioFrameTick | 23756 |
|
|
| jlAudioIsPlayingMod | 84472 |
|
|
| surfaceMarkDirtyRect (via jlFillRect 32x32) | 8965 |
|
|
| jlSpriteDraw unaligned | 8030 |
|
|
| jlSpriteDraw sweep16 | 8470 |
|
|
| jlTilePaste map 10x5 | 8305 |
|
|
| gameFrame composite | 938 |
|
|
| jlTileMapPaste 10x5 | 8030 |
|
|
| gameFrameClean composite | 1245 |
|
|
|
|
The tell is in the table itself, no model needed: 26 of the 39 rows land
|
|
inside a single 7,316-9,405 band -- a 1.29x spread across ops whose real
|
|
work differs by orders of magnitude. `jlDrawPixel` (8,580), a 100x100
|
|
rect outline (8,470) and a 16x16 sprite draw (8,250) cannot all cost the
|
|
same; `jlFillRect 80x80` (22,182) cannot be 2.4x FASTER than `jlFillRect
|
|
16x16` (9,295); `jlSurfaceClear` (8,775) cannot land within 1.2x of
|
|
`jlSamplePixel` (10,395). The physics check, in the style of artifact 2:
|
|
the stage is 4 x 8,000 = 32,000 bytes, so 8,775 clears/sec is 114
|
|
us/clear = ~1,140 cycles at 10 MHz = 28 bytes PER CYCLE. Even at the ST
|
|
rate card's write-only fill rate of ~2.2 cyc/B, 32,000 bytes is ~70k
|
|
cycles = ~7.0 ms = ~140 ops/sec, so that row reads ~60x high. Same for
|
|
the composite: `gameFrame` at 938/s is 1.07 ms = ~10,700 cycles for a
|
|
256x96 fill + 16 tile pastes + 3 saveAndDraw + 3 restores + a 96-row
|
|
band present, when the fill ALONE is 12,288 B x 2.2 = 27k cycles (the
|
|
very figure this file uses for the ST gameFrame ceiling) -- 2.5x the
|
|
whole measured frame. Only the cheap rows survive: at ~8 us/call
|
|
`jlMouseX` (125,529), `jlKeyDown` (53,006) and `jlAudioIsPlayingMod`
|
|
(84,472) poll the clock far more often than once per frame and read
|
|
honestly.
|
|
|
|
For calibration once the clock is fixed, this port sits between the two
|
|
68k ports already in the table: a 10 MHz 68000 with NO blitter -- the
|
|
ST's situation with 25% more clock -- writing a compact 4-plane surface
|
|
in plain malloc'd main RAM (no Chip RAM constraint, nothing but the CPU
|
|
ever reads it) and then scattering 32,000 bytes/frame into TVRAM at its
|
|
~1.92-cycle access penalty. So CPU-bound rows should be expected ABOVE
|
|
the 8.0 MHz ST roughly on clock ratio, while the present should land
|
|
between the ST (bus-floor CPU copy, 8 MHz) and the Amiga (7.09 MHz but a
|
|
blitter and display-DMA contention). None of that is measured yet, and
|
|
none of it can be until artifact 5 is closed.
|
|
|
|
## Measurement honesty (read before trusting any number)
|
|
|
|
Five measurement artifacts have shaped this table's history. Three are
|
|
fixed, one is inherent, and one -- the X68000 frame clock -- is OPEN and
|
|
invalidates that port's entire ops/sec column: know them before comparing
|
|
rows:
|
|
|
|
1. **Per-iteration poll tax -- FIXED (Phase 0).** The pre-audit bench
|
|
loop called jlFrameCount() between every op; on the IIgs that was a
|
|
GetTick toolbox chain (~600-800 cycles), so every small-op number
|
|
carried the harness cost, not the op cost. Ops now run in adaptive
|
|
batches per poll. Small-op numbers jumped 2-10x on every port when
|
|
this landed; never compare against pre-Phase-0 captures.
|
|
2. **SEI tick loss -- INHERENT on IIgs, rows tagged below.** The
|
|
benchmark clock is jlFrameCount = the VBL-interrupt-driven GetTick.
|
|
An op that holds SEI while it runs suppresses those interrupts, the
|
|
clock loses ticks, and the op over-reports. The three SEI-holding
|
|
rows -- `jlSurfaceClear`, `jlFillRect 320x200`, and
|
|
`jlStagePresent full` -- are CLOCK-UNRELIABLE in the IIgs column.
|
|
The physics check: a full-screen op moves 32000 bytes at ~6
|
|
cyc/word, so ~29 ops/sec is the hard ceiling at 2.8 MHz. The
|
|
present row's 68 and the clear row's 35 sit above it -- inflated;
|
|
the honest values are at or below the ceiling.
|
|
3. **ST frame-rate miscalibration -- FOUND and FIXED 2026-07-06; the
|
|
ST column below is the corrected (millis-clock) capture.** Before the
|
|
fix, ops/sec was `iters * jlFrameHz() / actualFrames` and the ST's
|
|
`jlpFrameHz()` hardcoded 50 -- but Hatari runs the emulated ST at
|
|
~60 Hz VBL, so every ST number was scaled by 50/60 ~= 0.83 (~17%
|
|
pessimistic). Caught by cross-checking against UBER's independent
|
|
Timer-C 200 Hz millis clock (refresh-independent), which ran ~16-22%
|
|
faster; the Amiga's two clocks agreed exactly (FS-UAE = PAL 50 Hz),
|
|
confirming it was ST-only. Two fixes landed: (a) UBER now computes
|
|
ops/sec from `jlMillisElapsed` (its own hardware clock on the ST and
|
|
DOS; derived from the frame counter on the IIgs -- identical to the
|
|
old formula -- and on the Amiga and X68000, neither of which
|
|
overrides jlpMillisElapsed; on the X68000 that counter is POLLED, so
|
|
both UBER clocks carry the same error and the frame-vs-millis
|
|
cross-check cannot see it -- artifact 5), and (b) ST `jlpFrameHz()` now reads the shifter
|
|
resolution + sync-mode registers to return the true 50/60/71 Hz. The
|
|
per-op `UBER-CLK:` log line reports frame-vs-millis as a standing
|
|
cross-check (they now agree). ST cells rose ~17% (e.g. jlSpriteDraw
|
|
503->585, jlFillRect 80x80 97->115); DOS/IIgs/Amiga unchanged.
|
|
4. **ST idle-audio ISR tax -- FOUND and FIXED 2026-07-07; the ST
|
|
column below is the post-fix capture.** jlpAudioInit started the
|
|
12.3 kHz Timer-A PWM ISR at init and left it running forever, even
|
|
silent (~320 cycles/tick = ~49.5% of the CPU), and UBER inits audio
|
|
before timing anything. Every ST capture before 2026-07-07 is ~2x
|
|
pessimistic. Timer A is demand-driven now (runs only while a mod or
|
|
SFX is audible), so the benches measure the op and an idle game
|
|
gets the whole CPU. Amiga/DOS/IIgs audited clean for the same bug
|
|
class (~1.8% / ~0.5% / 0% idle cost).
|
|
|
|
5. **X68000 polled frame clock -- OPEN; that port's whole ops/sec
|
|
column is invalid.** _iocs_vdispst HANGS the machine when handed a
|
|
plain C handler, so the V-DISP interrupt is never installed
|
|
(src/x68000/hal.c:85-92; gVdispInstalled stays false) and
|
|
jlpFrameCount instead edge-detects the MFP GPIP V-DISP bit each time
|
|
something calls it (hal.c:310-323). A polled edge detector loses
|
|
ticks exactly when the work is heavy, and the HAL says so in its own
|
|
comment: "Measured: 400 audio refills across ~19 frames reported ZERO
|
|
elapsed frames, because nothing polled in between" (hal.c:275-279).
|
|
UBER polls once per 16-op batch (uber.c:201-219), so any op whose
|
|
batch stretches past a V-DISP period makes the counter under-count,
|
|
and ops/sec = iters * 1000 / millis over-reports by that same factor.
|
|
The frame-vs-millis cross-check built for artifact 3 cannot catch it:
|
|
the X68000 has no jlpMillisElapsed override, so millis comes from
|
|
jlpGenericMillisElapsed, which is computed FROM jlpFrameCount
|
|
(src/core/port.h:753-758, src/generic/genericPort.c:52-97) -- every
|
|
UBER-CLK line on that port compares a number with itself, which is
|
|
why they all agree to within 0.5%. Cheap rows (jlMouseX, jlKeyDown,
|
|
jlAudioIsPlayingMod) poll often enough to catch every edge and read
|
|
honestly; everything else is inflated, ~60x on the full-screen rows.
|
|
THE FIX is recorded in the HAL: an asm thunk for _iocs_vdispst (save
|
|
d0-d1/a0-a1, call, restore, correct return) so the interrupt owns the
|
|
counter (hal.c:87-91, 298-300). Until that lands the X68000 gates on
|
|
HASHES ONLY -- it is a correctness column, not a performance column.
|
|
|
|
## Baseline (2026-07-08): absolute ops/sec per port
|
|
|
|
The IIgs is the reference and the perf floor (every other port must
|
|
meet or beat it -- project directive). Non-IIgs cells show absolute
|
|
ops/sec plus percentage of the IIgs number; sub-100% cells are bolded
|
|
as below-floor. `tools/uber-perf-table` emits this table directly;
|
|
regenerate after any re-capture (Amiga needs TIMEOUT=600 -- the
|
|
default cuts off the final checks). The tool still knows only the
|
|
original four ports (its PORTS list, tools/uber-perf-table:40-45) and
|
|
there is no bench-x68000.sh, so an X68000 column has to be added by
|
|
hand from a serial-tee capture -- see the 2026-08-05 entry. Capture provenance: all four
|
|
ports 2026-07-08 from a full `make clean` rebuild (Phase 6 W1+W2+W3
|
|
landed: fused IIgs sprite/fillRect entries, sprite-mark
|
|
specialization, per-row/fused presents on Amiga/ST/IIgs, ST movep
|
|
tile singles, DOS map walker, Amiga blitter copyRect + map hoist);
|
|
51/51 golden hashes x4 on this exact build; Amiga solo TIMEOUT=600;
|
|
IIgs from a fresh `make iigs-disk` image.
|
|
|
|
| Op | IIgs (ops/sec) | Amiga (ops/sec, % of IIGS) | Atari ST (ops/sec, % of IIGS) | DOS (ops/sec, % of IIGS) |
|
|
| --- | --- | --- | --- | --- |
|
|
| jlSurfaceClear | 33 | 75 (227%) | 88 (267%) | 66 (200%) |
|
|
| jlPaletteSet | 1561 | 11503 (737%) | 10388 (665%) | 29828 (1911%) |
|
|
| jlScbSetRange | 163 | 4003 (2456%) | 4833 (2965%) | 8491 (5209%) |
|
|
| jlDrawPixel | 5576 | 5903 (106%) | 6522 (117%) | 9009 (162%) |
|
|
| jlDrawLine H | 1322 | 1753 (133%) | 2670 (202%) | 5682 (430%) |
|
|
| jlDrawLine V | 104 | 303 (291%) | 261 (251%) | 456 (438%) |
|
|
| jlDrawLine diag | 42 | **40 (95%)** | 88 (210%) | 109 (260%) |
|
|
| jlDrawRect 100x100 | 110 | 285 (259%) | 279 (254%) | 470 (427%) |
|
|
| jlDrawCircle r=16 | 303 | **285 (94%)** | 359 (118%) | 461 (152%) |
|
|
| jlDrawCircle r=80 | 70 | **63 (90%)** | 83 (119%) | 98 (140%) |
|
|
| jlFillRect 16x16 | 785 | 1153 (147%) | 1225 (156%) | 3017 (384%) |
|
|
| jlFillRect 80x80 | 133 | 285 (214%) | 240 (180%) | 412 (310%) |
|
|
| jlFillRect 320x200 | 22 | 66 (300%) | 77 (350%) | 59 (268%) |
|
|
| jlFillCircle r=40 | 42 | **31 (74%)** | 155 (369%) | 156 (371%) |
|
|
| jlSamplePixel | 4797 | 7253 (151%) | 9784 (204%) | 46266 (964%) |
|
|
| jlTileFill | 3239 | 3753 (116%) | 3855 (119%) | 11824 (365%) |
|
|
| jlTileCopy | 1981 | 2903 (147%) | 3626 (183%) | 10910 (551%) |
|
|
| jlTileCopyMasked | 681 | 1003 (147%) | 1749 (257%) | 3391 (498%) |
|
|
| jlTilePaste | 2700 | 3753 (139%) | 4685 (174%) | 12575 (466%) |
|
|
| jlTileSnap | 2520 | 6103 (242%) | 8516 (338%) | 19218 (763%) |
|
|
| jlSpriteSaveUnder | 602 | 2053 (341%) | 2611 (434%) | 10718 (1780%) |
|
|
| jlSpriteDraw | 1142 | 1153 (101%) | 1341 (117%) | 8146 (713%) |
|
|
| jlSpriteRestoreUnder | 662 | 1603 (242%) | 1865 (282%) | 7826 (1182%) |
|
|
| jlSpriteSaveAndDraw | 423 | 803 (190%) | 934 (221%) | 5478 (1295%) |
|
|
| jlStagePresent full | 73 | 609 (834%) | 407 (558%) | 1132 (1551%) |
|
|
| jlInputPoll | 229 | 4003 (1748%) | 2788 (1217%) | 3148 (1375%) |
|
|
| jlKeyDown | 10191 | 39753 (390%) | 44448 (436%) | 77688 (762%) |
|
|
| jlKeyPressed | 11432 | 38003 (332%) | 44448 (389%) | 74903 (655%) |
|
|
| jlMouseX | 20138 | 97703 (485%) | 117920 (586%) | 155583 (773%) |
|
|
| joeyJoyConnected | 10191 | 38903 (382%) | 44260 (434%) | 77697 (762%) |
|
|
| jlAudioFrameTick | 27612 | 56503 (205%) | 39885 (144%) | **11490 (42%)** |
|
|
| jlAudioIsPlayingMod | 11029 | 56453 (512%) | 60441 (548%) | 127856 (1159%) |
|
|
| surfaceMarkDirtyRect (via jlFillRect 32x32) | 397 | 853 (215%) | 774 (195%) | 1479 (373%) |
|
|
| jlSpriteDraw unaligned | 1022 | **953 (93%)** | 1089 (107%) | 6316 (618%) |
|
|
| jlSpriteDraw sweep16 | 67 | **58 (87%)** | 70 (104%) | 463 (691%) |
|
|
| jlTilePaste map 10x5 | 59 | 75 (127%) | 94 (159%) | 257 (436%) |
|
|
| gameFrame composite | 12 | 31 (258%) | 32 (267%) | 19 (158%) |
|
|
| jlTileMapPaste 10x5 | 140 | 191 (136%) | 346 (247%) | 1224 (874%) |
|
|
| gameFrameClean composite | 20 | 71 (355%) | 90 (450%) | 192 (960%) |
|
|
|
|
> **IIgs full-screen ceiling (~29 ops/sec).** A full-screen op moves
|
|
> 32000 bytes = 16000 word-stores x 6 cyc (STA long,X / PEI, both
|
|
> 3 cyc/byte) / 2.8 MHz ~= 34 ms ~= 29 ops/sec maximum. So
|
|
> `jlSurfaceClear`, `jlFillRect 320x200`, and `jlStagePresent full`
|
|
> cannot legitimately exceed ~29; a higher reading means the benchmark
|
|
> clock was perturbed. The clock is `jlFrameCount` = the VBL-interrupt-
|
|
> driven GetTick, so an op that holds `SEI` while it runs can over-
|
|
> report its ops/sec. Treat full-screen IIgs numbers above ~29 as
|
|
> inflated and cross-check against the cycle model.
|
|
|
|
> **IIgs full-screen writes: the paper ceiling is refuted in MAME
|
|
> (Phase 6 W2).** The old note here derived ~34 ms / ~29 ops/sec for
|
|
> any full-screen op from 3 cyc/byte stores. The W2 fitted model --
|
|
> which closes P1, P2, and the idle-present row simultaneously --
|
|
> measured a shadowed push write at ~1.73 us (~4.8 fast cycles), so
|
|
> the honest MAME full-screen write floor is ~55 ms of writes alone;
|
|
> on real hardware (datasheet ~0.98 us/write) it is ~31 ms. The
|
|
> `jlStagePresent full` row is NOT a full-screen copy either way: it
|
|
> is the all-clean idle present (early-out scan only), which is why
|
|
> it reads far above any copy ceiling on every port. The GetTick
|
|
> clock itself is proven honest post-SEI-chunking (Lua cross-clock,
|
|
> tick-loss ~1.00); `jlSurfaceClear` remains the one mildly inflated
|
|
> row (1.21x).
|
|
|
|
## Re-derived native-technique ceilings (NATIVE-PERF Phase 6 close-out, 2026-07-08)
|
|
|
|
The Phase-0 ceilings were paper models. Three measurement waves (W0
|
|
probes + ledgers, W1 IIgs sprite autopsy + fusion, W2 present fixes +
|
|
fitted IIgs write model, W3 tile engines) invalidated or refined
|
|
several of them; this section re-derives every headline ceiling from
|
|
the MEASURED models and gates each row against the directive bar
|
|
(**measured within ~1.5x of hand-coded native technique for the row's
|
|
exact work**). "Ceiling" = the ops/sec a hand-coded native routine
|
|
would achieve doing the row's exact work -- pixel/byte traffic at the
|
|
measured machine rate, plus a minimal call and the dirty-band
|
|
bookkeeping the present contract requires. Gap = ceiling / measured.
|
|
Measured values: golden rows from the 2026-07-08 PERF.md capture;
|
|
probe rows (P1/P2/P8) from the Phase-6 W0/W2 tracker entries. Gaps >
|
|
1.5x are bolded. Cells marked UNKNOWN have no recorded model and no
|
|
honest derivation -- they are bounds, not ceilings.
|
|
|
|
**Superseded by this section:** (a) the "IIgs full-screen ceiling
|
|
(~29 ops/sec)" callout above -- the 34 ms full-screen "PEI floor" is
|
|
REFUTED in MAME: under the fitted write model (below), 32,000 shadowed
|
|
bytes cost ~55.4 ms of writes alone, so the honest MAME full-present
|
|
ceiling is ~14.5/s (~22/s real-HW variant), and the golden
|
|
`jlStagePresent full` reading (73/s) is the idle-early-out artifact,
|
|
not a copy; (b) the Phase-0 ST tile ceilings (12,700-15,500/s --
|
|
assumed byte-move bodies; the landed movep engine beats them); (c) the
|
|
Phase-0 IIgs sprite-draw ceiling (4,300/s -- assumed no
|
|
derive/mark/wrapper; W1 autopsy honest ceiling is 2,500-2,650/s);
|
|
(d) the Phase-0 Amiga/ST/DOS "present full copy" ceilings (the timed
|
|
row never re-dirtied; the P1/P2 probe models below are the real ones).
|
|
|
|
Row shapes (exact UBER geometry the ceilings are computed for):
|
|
tile ops are one 8x8 tile; the map row is 10x5 = 50 tiles; sprite
|
|
per-op rows are a 16x16 sprite at (40,30) -- x&15 = 8, so the 68k
|
|
save/restore window is TWO 16-px groups = 256 B (IIgs/DOS chunky
|
|
window is 128 B); gameFrame = 256x96 fill + 16 tile pastes + 3
|
|
saveAndDraw + 3 restores (sprites mod-16 aligned = 1-group windows) +
|
|
a 96-row x 256-px dirty present; gameFrameClean = 3 16x16 copyRect
|
|
erases + 3 draws + present; P1 = the 96-row x 256-px band alone
|
|
(12,288 shadow bytes; 24,576 VGA bytes on DOS); P2 = three 16x16
|
|
windows (384 B; 768 VGA bytes). Clocks: ST 8.0 MHz, Amiga 7.09 MHz,
|
|
IIgs 2.8 MHz; DOS has no cycle model -- only recorded rates are used.
|
|
|
|
### Measured rate cards (replace the Phase-0 paper inputs)
|
|
|
|
* **ST (68000):** bus floor 4.0 cyc/B copied; move.l inline 5.0 cyc/B;
|
|
movem streams ~4.6-4.8 cyc/B (write-only fill ~2.2 cyc/B); landed
|
|
movep tile bodies 36 cyc/tile-row (paste/snap) and 48 (copy);
|
|
specialized whole-tile mark ~480 cyc; measured per-present idle base
|
|
0.87 ms (hunt-3 refresh: jlStagePresent full 1150/s post the
|
|
group-skip landings; the old 2.2 ms / P8 452/s figure predates them
|
|
-- every ceiling row below that adds "+ 2.2 ms base" is pessimistic
|
|
by ~1.3 ms and ST P2's honest re-derived ceiling is ~775/s, which
|
|
RE-OPENS that row). P1 machine ceiling ~100 ops/s (session model)
|
|
carries the same staleness.
|
|
* **Amiga:** blitter A->D ~2 chip cyc/word + ~230 cyc/plane setup +
|
|
~240 cyc Own/Disown; display-DMA contention ~2x on chip traffic
|
|
(Phase-0 full-blit 110/s precedent); measured contended CPU tile
|
|
body ~700 cyc/cell (backed out of the landed map walker, 191 maps/s
|
|
= 742 cyc/tile incl. walk); P8 idle base 0.87 ms (hunt-3 refresh:
|
|
jlStagePresent full 1143/s -- the old NEVER RECORDED note is
|
|
resolved by the golden idle-dominated row post group-skips).
|
|
* **DOS:** the W0 "~1.7 us/VGA byte -- pure hardware rate" model is
|
|
REFUTED (hunt-3): the dword-fused expand measured probe present96 at
|
|
29 ops/s = ~1.40 us/B over 24,576 B, EXCEEDING the old ceiling (~24)
|
|
-- under DOSBox's instruction-counting core the write loop was
|
|
software-bound, not hardware-bound. DOS present ceilings should be
|
|
re-fit from ~1.40 us/B; gameFrameClean is PASS-at-floor (245/s vs
|
|
the probe-split-derived ~244 floor);
|
|
CPU-side recorded models only: single-tile paste ~57,000/s (Phase-0,
|
|
unrevised) and map walker ~76,000 tiles/s (W3: ~26 measured vs 18-20
|
|
hand instructions/cell).
|
|
* **IIgs:** MAME-fitted write model (closed the P1/P2/P8 ledgers
|
|
simultaneously): shadowed SHR push write wSh ~1.73 us/B, slow-I/O
|
|
softswitch access ~1.0 us; measured per-present fixed base 2.75 ms
|
|
(hunt-3 probe: presentIdle 363/s; the original 13.7 ms figure died
|
|
with the band-memset fix -- any ceiling below still adding "+13.7"
|
|
is pessimistic by ~11 ms). Real-HW datasheet variant: wSh ~0.977
|
|
us/B (fixed base assumed unchanged -- unverified on hardware). Tile hand-call floor
|
|
480 cyc; W1 sprite autopsy: honest full-op draw ~1,060-1,120 cyc
|
|
(body ~670 + minimal per-row mark ~390 + 3-far-load derive + JSL;
|
|
the fnAddr cache was built, measured a LOSS, and removed).
|
|
|
|
### Atari ST (8.0 MHz 68000)
|
|
|
|
| Row | Ceiling (ops/s) | Derivation | Measured | Gap | Bar |
|
|
| --- | --- | --- | --- | --- | --- |
|
|
| jlTilePaste | ~9,200 | movep body 8x36=288 + mark ~480 + call ~100 = 868 cyc | 4,685 | **2.0x** | FAIL |
|
|
| jlTileCopy | ~8,300 | movep body 8x48=384 + 480 + 100 = 964 cyc | 3,626 | **2.3x** | FAIL |
|
|
| jlTileSnap | ~20,600 | body 288 + call ~100 = 388 cyc (no mark; measured overhead is ~651) | 8,516 | **2.4x** | FAIL |
|
|
| jlTileMapPaste 10x5 | ~440 | 50 x ~350 cyc/tile (movep-honest) + one mark 480 + one validation ~200 = 18.2k cyc | 346 | 1.27x | PASS |
|
|
| jlSpriteDraw | 2,235-2,750 | Phase-0 pre-shifted movem-RMW model, 2,909-3,580 cyc -- UNREVISED paper | 1,341 | **1.7-2.1x** | FAIL |
|
|
| jlSpriteSaveUnder | ~5,300 | 2-group window 256 B x 5.0 cyc/B + row stride ~230 = 1,510 cyc. P7-1 probe split (2026-07-09): full call 3,064 cyc = wrapper+validation 1,088 + dispatch/metadata ~660 + body 1,310; the window delta (g16 row) measured the body at 5.1 cyc/B = AT the move.l floor -- the whole gap is C glue | 2,611 | **2.0x** | FAIL (lever: 68k wrapper trim/fusion) |
|
|
| jlSpriteRestoreUnder | ~4,000 | save copy 1,510 + sprite mark ~480 = 1,990 cyc. P7-1 probe: full 4,211 cyc, validation alone 422 (odd-bx row) | 1,900 | **2.0x** | FAIL (same lever) |
|
|
| gameFrame | ~58 fps | fill 12,288 B x 2.2 = 27k + 16 pastes 13.9k + 3 saves 2.6k + 3 draws 9.3k (mid-range of the paper draw model) + 3 restores 4.1k + present96 80k = 136.9k cyc = 17.1 ms | 32 | **1.8x** | FAIL |
|
|
| gameFrameClean | ~245 | 3 copyRect x ~750 cyc + 3 draws 9.3k + P2-class present 20.8k = 32.4k cyc = 4.0 ms | 90 | **2.7x** | FAIL |
|
|
| P1 present96 | ~100 | model: 12,288 B x 4.0 cyc/B = 6.1 ms + P8 base 2.2 ms + snapshot traffic in one fused 200-row scan/snapshot pass ~= 10 ms | 73 | 1.37x | PASS |
|
|
| P2 present3win | ~385 | measured idle base 2.2 ms (P8 452/s) + 384 B copy+snapshot x ~8 cyc/B ~= 2.6 ms | 245 | **~1.6x** | FAIL (marginal) |
|
|
|
|
### Amiga (7.09 MHz 68000 + blitter)
|
|
|
|
| Row | Ceiling (ops/s) | Derivation | Measured | Gap | Bar |
|
|
| --- | --- | --- | --- | --- | --- |
|
|
| jlTilePaste | ~5,500 | measured contended body ~700 + mark 480 + call ~100 = 1,280 cyc (uncontended instruction model gives ~6,100-6,400 -> gap 1.6-1.7; the Phase-0 18% pair discrepancy persists as this band) | 3,753 | ~1.48x | PASS (at bar) |
|
|
| jlTileCopy | ~4,800-5,300 | chip-to-chip body ~750-900 + 480 + 100 cyc | 2,903 | **1.7-1.8x** | FAIL (marginal) |
|
|
| jlTileSnap | ~8,900 | body ~700 + call ~100 = 800 cyc (no mark; writes go to fast RAM) | 6,103 | ~1.45x | PASS (at bar) |
|
|
| jlTileMapPaste 10x5 | ~200 | 50 x ~700 + mark 480 + validation ~200 = 35.7k cyc; the landed walker already beat its own design model (176-186 -> 191) | 191 | ~1.05x | PASS |
|
|
| jlSpriteDraw | ~1,350 | Phase-0 compiled-CPU ceiling; the 3,600-4,300/s blitter cookie-cut is DEFERRED by recon -- sync WaitBlit forfeits the win at <= 16x16 (this row's size) | 1,153 | 1.17x | PASS |
|
|
| jlSpriteSaveUnder | ~4,400-6,100 | SUPERSEDES the blitter paper (6,300-7,400): P7-1 probe (2026-07-09) measured the CPU body at 3.8 cyc/B via the window delta (482 cyc/128 B), so body ~960-1,900 cyc (contention band) + call ~200. Full call 3,372 cyc = wrapper+validation 1,524 + dispatch/metadata ~880 + body -- the gap is C glue, not the copy | 2,103 | **~2.1-2.9x** | FAIL (lever: 68k wrapper trim/fusion) |
|
|
| jlSpriteRestoreUnder | ~2,900-3,700 | body + mark ~480 + call (same probe-derived band); full 4,423 cyc, validation alone 672 (odd-bx row) | 1,603 | **~1.8-2.3x** | FAIL (same lever) |
|
|
| gameFrame | ~70 fps | fill blit 13.4k x2 contention = 27k + 16 pastes 20.5k + 3 saves 3k + 3 draws 15.8k + 3 restores 4.4k (sprite components interpolated from the paper models) + present96 29k = 99.7k cyc = 14.1 ms | 31 | **2.3x** | FAIL |
|
|
| gameFrameClean | ~230 | 3 blit copyRects ~6.8k contended + 3 draws 15.8k + P2 present ~8k = 30.6k cyc = 4.3 ms | 71 | **3.2x** | FAIL |
|
|
| P1 present96 | ~245 | 4-plane modulo blit 4x(230 + 1,536 w x 2) + 240 = 13.4k cyc, x2 contention + union scan ~2k = 29k cyc = 4.1 ms (the landed P7-3 blitter flush now takes this path; CPU-copy variant was 12,288 B x 4 cyc/B + scan ~= 7.5 ms -> ~133/s) | 78 | **~3.1x** | FAIL |
|
|
| P2 present3win | UNKNOWN (write-only bound ~890-1,300) | 12 plane-blit setups 2.8k + 192 w x2 contention + Own/Disown + scan ~2k ~= 5.4-8k cyc = 890-1,310 ops/s; honest ceiling needs the Amiga P8 idle base = 661/s = 1.51 ms. Component split (2026-07-09 skip-mask probe): scan ~4.9 ms, flush ~3.3 ms (chip->chip CPU copy, below the 128-word blitter threshold), flip ~0.4 ms, residual ~1.2 ms. TWO levers landed: (1) presentScan.s 4-row fast path cut the scan (106 -> 128, +21%, after fixing a phantom-row-200 OOB); (2) the flush moved to the blitter by lowering AMIGA_PRESENT_BLIT_MIN_WORDS 128 -> 16 (chip->chip DMA vs contention-bound CPU copy): 128 -> 153 (+20%). Both 51/51 + P11 | 153 | **<= ~6-8x vs bound** | FAIL/UNKNOWN |
|
|
|
|
### DOS (AT-class VGA; no cycle model -- recorded rates only)
|
|
|
|
| Row | Ceiling (ops/s) | Derivation | Measured | Gap | Bar |
|
|
| --- | --- | --- | --- | --- | --- |
|
|
| jlTilePaste | ~57,000 | Phase-0 single-tile model -- UNREVISED (W3 walker data is consistent with it) | 12,575 | **4.5x** | FAIL |
|
|
| jlTileCopy | ~57,000 class | same 64-B traffic as paste; no separate model recorded | 10,910 | **~5.2x** | FAIL |
|
|
| jlTileSnap | >= ~57,000 class | paste class minus the mark; no separate model recorded | 19,218 | **~3.0x** | FAIL |
|
|
| jlTileMapPaste 10x5 | ~1,520 | recorded W3 model: ~76k tiles/s (walker at 61,200 x 26/[18-20] hand instructions/cell) / 50 | 1,224 | 1.24x | PASS (residue structural: map indirection + mark) |
|
|
| jlSpriteDraw | ~11,000 | Phase-0 model -- UNREVISED | 8,146 | 1.35x | PASS |
|
|
| jlSpriteSaveUnder | 14,500-18,000 | Phase-0 model -- UNREVISED | 10,718 | 1.35-1.68x | AT BAR (range straddles) |
|
|
| jlSpriteRestoreUnder | 14,500-18,000 | Phase-0 model -- UNREVISED (add mark: real ceiling somewhat lower) | 7,826 | **1.9-2.3x** | FAIL |
|
|
| gameFrame | ~22 fps | present writes 24,576 B x 1.7 us = 41.8 ms + components ~2.5 ms ~= 44.3 ms (component figure not derivable from recorded rates -- no DOS fill rate; verdict insensitive: even at the measured P4 9.2 ms the ceiling is ~19.6 fps, gap ~1.03); W0 verdict: present-bound AT hardware | 19 | 1.2x | PASS |
|
|
| gameFrameClean | UNKNOWN (upper bound ~500) | erases+draws ~0.7 ms + present writes 768 B x 1.7 us = 1.3 ms; per-present fixed scan (~2.0 ms observed) never modeled | 192 | **<= ~2.6x vs bound** | FAIL/UNKNOWN |
|
|
| P1 present96 | ~24 | 24,576 VGA B x 1.7 us = 41.8 ms -- pure hardware rate | 23 | 1.04x | PASS (AT hardware) |
|
|
| P2 present3win | UNKNOWN (upper bound ~766) | 768 B x 1.7 us = 1.3 ms writes only; fixed base unmeasured (W0 closed DOS present work) | 305 | **<= ~2.5x vs bound** | FAIL/UNKNOWN |
|
|
|
|
### Apple IIgs (2.8 MHz 65816; MAME-fitted write model)
|
|
|
|
| Row | Ceiling (ops/s) | Derivation | Measured | Gap | Bar |
|
|
| --- | --- | --- | --- | --- | --- |
|
|
| jlTilePaste | ~5,830 | recorded 480-cyc hand per-tile call | 2,700 | **2.2x** | FAIL |
|
|
| jlTileCopy | ~4,860 | 480 + ~96 cyc extra far-src reads = 576 cyc | 1,981 | **2.5x** | FAIL |
|
|
| jlTileSnap | ~5,800 | 480-cyc class (mark savings ~= far-read tax) | 2,520 | **2.3x** | FAIL |
|
|
| jlTileMapPaste 10x5 | ~140 | 50 x ~390 cyc/tile floor (no tracker source; within noise of the landed ~400-cyc/tile walker) + one mark ~= 19.9k cyc; the landed walker already runs BELOW the 480-cyc per-call ceiling | 140 | ~1.0x | PASS |
|
|
| jlSpriteDraw | 2,500-2,650 | W1 autopsy honest full-op model: ~1,060-1,120 cyc = body ~670 + per-row mark ~390 + 3-far-load derive + JSL (fnAddr cache rejected by measurement) | 1,142 | **~2.2-2.3x** | FAIL |
|
|
| jlSpriteSaveUnder | ~2,050 | MVN window body ~1,111 cyc (128 B x ~7 cyc/B + row stepping; = Phase-0 2,520/s) + derive/JSL ~250 = 1,360 cyc | 602 | **3.4x** | FAIL |
|
|
| jlSpriteRestoreUnder | ~1,600 | save body 1,111 + fused mark ~390 + derive/JSL ~250 = 1,750 cyc (matches the W1 "restore 1,600+" honest target) | 662 | **2.4x** | FAIL |
|
|
| gameFrame | ~16.5 fps (real HW ~20) | P4 components ~20.4 ms (fill 6,144 w x 6 cyc = 13.2 + pastes 2.7 + saves 1.5 + draws 1.2 + restores 1.9) + present96 40.3 ms = 60.7 ms | 12 | 1.37x | PASS |
|
|
| gameFrameClean | ~60 | 3 stage-copy erases ~1.2 ms + 3 draws ~1.2 ms + P2 present 14.4 ms ~= 16.7 ms | 20 | **3.0x** | FAIL |
|
|
| P1 present96 | ~25 MAME (real HW ~35) | 15,360 B x 1.73 us = 26.6 ms writes + 13.7 ms measured base = 40.3 ms (landed Stage-B copies 13,824 B -> 37.6 ms -> ~27/s, gap 1.33x); minimal-copy variant (12,288 truly dirty B) 35.0 ms -> ~29/s, gap 1.43x -- PASS every way | 20 | 1.24x | PASS |
|
|
| P2 present3win | ~70 (real HW ~71) | 384 B x 1.73 us = 0.7 ms + 13.7 ms base = 14.4 ms | 52 | 1.34x | PASS |
|
|
|
|
IIgs real-HW-datasheet variants (wSh ~0.977 us/B, MAME-measured 13.7 ms
|
|
base assumed unchanged -- unverified on hardware): P1 15.0 + 13.7 =
|
|
28.7 ms -> ~35/s; P2 ~14.1 ms -> ~71/s; full 200-row present 31.3 +
|
|
13.7 = 45.0 ms -> ~22/s (vs ~14.5/s MAME-fitted); gameFrame ~49 ms ->
|
|
~20 fps. The MAME-fitted column is what the bench harness can verify;
|
|
the real-HW column is the datasheet claim.
|
|
|
|
### Rows still outside the 1.5x bar -- reasons and recorded levers
|
|
|
|
* **Tile singles, all four ports (1.7x-5.2x).** Bodies are at machine
|
|
floor (probe-validated splits, restated against the 2026-07-08
|
|
capture: ST paste overhead = 1,708 - 288 = 1,420 cyc, snap overhead
|
|
651 cyc with no mark; the W3-landing probe read 1,388/669); the gap
|
|
is the per-call public wrapper + validation + whole-tile mark
|
|
(Phase-2 exit finding: "remaining per-call floor = public wrapper +
|
|
one JSL/call"). Recorded answer is the batch API, which PASSES on
|
|
every port (1.0x-1.27x); no further singles lever is recorded --
|
|
the singles gap is accepted per-call API tax (absolute cost <= ~0.3
|
|
ms/call everywhere; IIgs tileCopy ~0.3 ms and tileSnap ~0.22 ms are
|
|
the worst cases, all other rows <= ~0.2 ms).
|
|
* **IIgs sprite rows (2.2-2.3x/3.4x/2.4x).** Autopsy buckets:
|
|
validation ~22% + wrapper residue in the register-starved public
|
|
wrappers; fusion already landed (+18-22%), the fnAddr cache measured
|
|
a loss and was removed. VALIDATION LEVER LANDED 2026-07-12 via the
|
|
trusted fast-path API (jlSprite{SaveUnder,RestoreUnder,SaveAndDraw}
|
|
Trusted, extended from the 68k P7-1 work): the trusted entries skip the
|
|
~22% validation and route into the existing fused MVN entries. IIgs
|
|
save 602->665 (+10.5%), restore 662->722 (+9%), saveAndDraw 423->455
|
|
(+7.6%); shrParity badRows=0, 51/51 golden (safe entries unchanged).
|
|
Smaller than the 68k wins because 65816 validation is a smaller
|
|
fraction. Do not resurrect the fnAddr cache without a compiler-level
|
|
win (LLVM816-ASKS candidate).
|
|
* **ST sprite rows (~2.0x) / Amiga save-restore (~1.8-2.9x) / DOS
|
|
restore (1.9x-2.3x).** The P7-1 layer-split probe (2026-07-09)
|
|
RESOLVED where the 68k gap lives: the copy bodies are AT the machine
|
|
floor (window-delta-measured 5.1 cyc/B ST / 3.8 cyc/B Amiga), and
|
|
~55-70% of every call is the C wrapper+validation (1,088 cyc ST /
|
|
1,524 Amiga for save; 422/672 for restore's validation alone) plus
|
|
dispatch/backup-metadata glue (~660-880 cyc). The old paper ceilings
|
|
(Amiga blitter 6,300-7,400) are superseded by probe-derived CPU
|
|
ceilings in the tables above; true gaps ~2x. LEVER ATTEMPT 1 (macro
|
|
tightening, 2026-07-11): REVERTED, net loss. Both class macros were
|
|
rewritten to their algebraically-minimal form, proven value-identical
|
|
(102k save + 1.1M restore cases, 0 mismatches) and gated 51/51 --
|
|
benched save bit-identical on both ports, restore neutral on ST but
|
|
-3% on Amiga (1603->1553; gcc-amigaos lowered the "simpler" C to +3
|
|
instructions). The wrapper is gated by register allocation (movem of
|
|
10-11 regs + interleaved validation), not arithmetic op count -- no
|
|
C micro-opt moves these rows, same compiler-bound wall as the IIgs
|
|
fnAddr-cache autopsy. LEVER ATTEMPT 2 (restore+draw mark fusion,
|
|
2026-07-11): LANDED, +5-6% on restore. Isolated the mark at ~26-29% of
|
|
a 68k restore (probe: restore to a non-stage surface skips it). Three
|
|
builds: a per-port body+mark asm shim REGRESSED both ports (broke the
|
|
always-inline body's shared loads + added a call layer); a lean
|
|
rolled-loop asm widen call REGRESSED (rolled dbra lost to gcc's
|
|
unrolled indexed mark); INLINING the unrolled 16-row mark into
|
|
jlSpriteRestoreUnder for the h==16 stage window (C only, no asm) WON --
|
|
ST restore 1900->1996, Amiga 1603->1703, both 51/51 + P11/P10/P5
|
|
parity. The recoverable win was the CALL BOUNDARY (only inlining
|
|
removes it; asm always keeps a jsr). Draw bundled via the same inline
|
|
(jlSpriteDraw + SaveAndDraw): Amiga draw +4% / saveAndDraw +6% /
|
|
unaligned +5%; ST draw neutral (masked body dwarfs the mark); DOS
|
|
untouched (guarded). gameFrame flat (present-bound). LEVER ATTEMPT 3
|
|
(TRUSTED fast-path entry, 2026-07-11): LANDED, the biggest 68k sprite
|
|
win yet. New opt-in public API (jlSpriteSaveUnderTrusted /
|
|
RestoreUnderTrusted / SaveAndDrawTrusted) that skips the per-call
|
|
geometry-validation chain for a caller that pre-compiles its sprites
|
|
and clamps positions on-screen (UB-if-violated contract; falls back to
|
|
the safe sibling for anything unrecognised; Amiga/ST fast path,
|
|
DOS just calls the safe entry). WINS ON ALL THREE COMPILED PORTS:
|
|
save ST 705->817 (+16%) / Amiga 657->753 (+15%) / IIgs 602->665
|
|
(+10.5%); restore ST 529->609 (+15%) / Amiga 545->609 (+12%) / IIgs
|
|
662->722 (+9%); saveAndDraw ST 257->289 (+12.5%) / Amiga 273->289
|
|
(+6%) / IIgs 423->455 (+7.6%). On 68k the win EXCEEDS the raw ~422/672
|
|
cyc validation because dropping the checks also shrank gcc's
|
|
frame/spills; IIgs routes into the fused MVN entries minus validation.
|
|
Parity gates pass (P10 ST, P11 Amiga, shrParity IIgs); DOS 51/51 +
|
|
IIgs 51/51 (falls back / safe entries unchanged). Batch APIs stay
|
|
descoped (dispatch alone ~3-6%); the blitter cookie-cut stays deferred
|
|
until a >= 32x32 golden row exists.
|
|
* **Amiga presents P1/P2 (+ both Amiga composites, 2.8x-5.3x; P2
|
|
bound-only).** W2 fixed the bounding-box over-copy (P2 copied bytes
|
|
4,992 -> 384 exact; W0's conviction figure was 3.5x vs the ~1,536
|
|
truly-dirty estimate) but the ~11 ms per-present fixed scan
|
|
survives (P2 = 11.1 ms to move 384 B; P1 even regressed 8% on added
|
|
scan cost -- accepted deviation). Recorded levers: fused-scan
|
|
present asm on the ST presentSlam pattern (W2 follow-up) and a
|
|
modulo-blitter present flush (the landed W3 copyRect blitter arm is
|
|
the template). This is the single largest remaining item in the
|
|
program.
|
|
* **ST P2 (~1.6x, marginal) and ST composites (1.8x/2.7x).** P2
|
|
residue is ~1.5 ms absolute (per-run move.l-chain entry + snapshot
|
|
maintenance); W2 closed ST present work and no lever is recorded.
|
|
gameFrame's gap is spread across sprite/fill wrapper taxes (no
|
|
single lever); gameFrameClean's was dominated by jlSurfaceCopyRect's
|
|
strided per-row memcpy dispatch -- the same overhead class the Amiga
|
|
W3 blitter item deleted. LANDED 2026-07-12 (#3): an ST move.l-chain
|
|
copyRect (src/atarist/copyRect.s, stCopyRectSpans68k) replaces the
|
|
per-row memcpy CALL for short spans (the 48 8-byte-row window copies
|
|
where mintlib memcpy's frame dwarfs the two move.l; long rows keep
|
|
memcpy past the 64-byte crossover). gameFrameClean 90 -> 120 ops/sec
|
|
(+33%), 51/51 + P10 displayMismatch=0; gameFrame unchanged (uses
|
|
save/restore, not copyRect). Bigger than expected -- the small-window
|
|
memcpy call overhead dominated the clean-buffer op.
|
|
* **IIgs gameFrameClean (was 3.0x).** Recorded forensic: ~30 ms/frame
|
|
unattributed, llvm-mos far-memcpy byte loops in the generic copyRect
|
|
erase engine (finding #79 class). LEVER LANDED 2026-07-12: an
|
|
IIgs-specific jlpSurfaceCopyRect override (src/iigs/hal.c, gated
|
|
JL_HAS_SURFACE_COPY_RECT) does an inline word copy for short spans --
|
|
compiles to `lda [dp],y / sta`, NO far-memcpy call (verified in the -S
|
|
output) -- for the 8-byte-row clean-buffer windows; long rows keep
|
|
memcpy. gameFrameClean 18 -> 24 ops/sec (+33%), 51/51 + shrParity.
|
|
NOTE: this was FIRST tried in the shared generic copyRect but that
|
|
REGRESSED DOS -12% (x86 rep-movs memcpy already beats an inline word
|
|
loop for 8-byte rows), so it is IIgs-only; DOS stays on generic memcpy.
|
|
Remaining IIgs gameFrameClean gap (if any) would want the flagged
|
|
llvm816 memcpy fix or an MVN block-copy for the long rows.
|
|
* **DOS gameFrameClean / P2 -- RESOLVED 2026-07-13 (perf-hunt-2 ranks
|
|
4/5/6).** The missing display gate now exists: P12 vgaMismatch (an
|
|
UBER_PROBE row + dosProbeVgaMismatch in src/dos/hal.c) re-derives
|
|
every VGA byte independently of the expand LUT and reads 0/0/0
|
|
across the battery. The per-present scan was cut by the 4-row dword
|
|
group skip (P8 idle 1137 -> 3881 ops/s, ~0.26 ms base) and the
|
|
expand loop dword-fused (two LUT words per 32-bit store; DOSBox's
|
|
instruction-counting core rewarded it directly): gameFrameClean 196
|
|
-> 243 ops/s (+24%), gameFrame 19 -> 23 (+21%), both 51/51. The
|
|
probe component split answers the old unknown: gameFrameClean at
|
|
244/s = 4.10 ms/frame = present 3.06 ms + window erases 0.70 ms +
|
|
sprite draws 0.34 ms -- the row is present-dominated and the
|
|
remaining present cost is expand + per-row glue at the measured
|
|
rate, not an unexplained residual. No further DOS present lever is
|
|
recorded. (-fomit-frame-pointer also landed for flag parity with
|
|
the 68k ports: input rows +28-29%, map paste +7%, zero regressions.)
|
|
|
|
### Assumptions
|
|
|
|
1. Clocks: ST 8.0 MHz, Amiga 7.09 MHz (PAL), IIgs 2.8 MHz; DOS has no
|
|
cycle model, so DOS ceilings use only the recorded rates (1.7
|
|
us/VGA byte, 57k paste, 76k tiles/s walker).
|
|
2. Irreducible per-call floors assumed: ~60-100 cyc call/shim on 68k,
|
|
~250 cyc JSL+derive on IIgs; the landed specialized dirty marks
|
|
(~480 cyc 68k whole-tile, ~390 cyc IIgs fused) are treated as
|
|
irreducible for row shapes that mark per call.
|
|
3. Amiga display-DMA contention factor ~2x on chip-RAM traffic, taken
|
|
from the Phase-0 full-blit 110/s precedent; uncontended variants
|
|
are shown wherever they would change a verdict.
|
|
4. The IIgs fixed present base was 13.7 ms MAME-measured (P8) when
|
|
the ceilings below were derived. 2026-07-13: ~11 ms of that base
|
|
was the dirty-band memset pair (see History) and is now ~2.75 ms
|
|
-- ceilings that add "+ 13.7 ms base" are stale and pessimistic;
|
|
re-derive with ~2.75 ms before gating new work on them. The
|
|
real-HW column assumption (base carries over unchanged) is still
|
|
unverified on hardware.
|
|
5. Composite ceilings are sums of component ceilings at the rows'
|
|
exact geometry (per-op sprite rows at x=40 use the 2-group 256-B
|
|
68k window; gameFrame's mod-16-aligned sprites use the 1-group
|
|
128-B window). Composite sprite components not separately recorded
|
|
(ST draws, Amiga saves/restores/copyRects) are interpolations
|
|
inside the quoted Phase-0 ranges.
|
|
6. Ceilings labeled UNREVISED (ST/Amiga/DOS sprite models, DOS tile
|
|
singles) are Phase-0 paper carried forward because no wave
|
|
re-measured them; their gaps are quoted as ranges and should be
|
|
re-derived before gating any new work on those rows. The ST P1
|
|
~100 ops/s machine ceiling is a session model consistent with the
|
|
P8 base + bus-floor copy, not a tracker-recorded number.
|
|
7. Where no model or measurement exists (Amiga/DOS P8 idle bases, DOS
|
|
copy/snap singles), the cell is an explicit upper bound or
|
|
UNKNOWN -- no ceiling was invented.
|
|
|
|
## Reading notes
|
|
|
|
* **Sprite rows measure COMPILED code on all five ports** since
|
|
NATIVE-PERF Phase 1 (2026-07-06): the 68k ports JIT all-shift draw
|
|
variants plus group-window save/restore (previously stubs that fell
|
|
to interpreters), IIgs codegen re-enabled via finding #77, DOS via
|
|
finding #74. The X68000 joined on the shared 68k PLANAR emitter with
|
|
no emitter changes -- it takes the AMIGA arm of
|
|
src/core/spriteDispatch.h (4-plane cdecl routines from
|
|
src/m68k/spriteEmitPlanar68k.c, one pre-shifted variant per x % 8
|
|
phase, all 8 compiled), because its surface stride is the Amiga's 40
|
|
bytes and the display's 128-byte text-plane stride never reaches the
|
|
emitter. The interpreted walkers remain only as arena-full
|
|
degrade paths -- and are proven bit-identical to the compiled code
|
|
by the 51-hash gate.
|
|
* **The below-floor cells are the standing punch list**, and after the
|
|
2026-07-07 audio-tax fix the ST has NONE -- every remaining
|
|
below-floor graphics cell is the Amiga's: the circle family (diag
|
|
line 95%, circle r=16 94%, r=80 87%, fillCircle 74% -- planar 4-plane
|
|
RMW tax) and the two sprite workload rows a hair under floor
|
|
(unaligned 95%, sweep16 89%; chip-RAM display-DMA contention that the
|
|
fast-RAM-code ST does not pay). DOS jlAudioFrameTick (42%) is the SB
|
|
half-buffer silence refill on an otherwise-trivial call -- it gates
|
|
nothing. Floor parity is effectively DONE; the open work is
|
|
ceiling-relative (NATIVE-PERF-PLAN.md Phase 2+), where every port
|
|
still runs 2-5x below hand-coded technique on tile/sprite glue.
|
|
Amiga jlFillCircle r=40 (74%) was probed
|
|
2026-07-06 with a full whole-circle asm routine (Bresenham + inline
|
|
4-plane long-fill span): it held 45/45 hashes but did NOT move the
|
|
number (34 vs 31, within the coarse 11-iter sample), so the per-span
|
|
C dispatch is NOT the bottleneck -- the asm was reverted. The real cost
|
|
is the midpoint fill's 8-way symmetry filling each row 2-4x (idempotent
|
|
overlap): the true lever is a scanline rewrite (one span per row, no
|
|
overlap), which would roughly halve the byte writes and stay
|
|
hash-identical. NB: this op is timed at batch=1 (~29 ms each) by the
|
|
50 Hz frame counter, a coarse measurement. (The old note here blaming
|
|
a "4-5x model-vs-measured gap" partly on measurement was vindicated
|
|
2026-07-07: on the ST that gap was the idle-audio tax, artifact #4.)
|
|
* **jlRandom has no timed row.** Phase 8 (#43) rewrote its xorshift32
|
|
update in 16-bit halves on the IIgs only (~2-3x fewer cycles per
|
|
call on the 65816; 32-bit shifts there are per-bit helper loops).
|
|
Output is bit-identical -- host-proven over the golden sequence and
|
|
a 50M-state sweep, and gated by UBER's random-golden check on all
|
|
five ports.
|
|
* **Input predicates stay functions** (Phase 8 #40 decision): the
|
|
post-clock-fix numbers (12K-77K ops/sec) put call overhead nowhere
|
|
near a real frame budget; macro forms in the public header were
|
|
rejected as not worth the API exposure.
|
|
* **IIgs libc memset/memcpy remain ~4x slow** (finding #79,
|
|
toolchain-owned): llvm-mos runtime byte loops vs ORCA's MVN. The
|
|
jlScbSetRange and jlPaletteSet IIgs rows carry that tax; library-side
|
|
mitigations landed (#16 unrolled word copy, #21), the libc fix is
|
|
flagged to the llvm816 session.
|
|
|
|
## History
|
|
|
|
- 2026-07-20 (later still): music layer v2 = the complete feature
|
|
set. jlAudioNoise percussion voice implemented natively on all four
|
|
ports (ST YM noise generator on channel C with shared-volume guards
|
|
both directions + a Supexec'd PSG all-off in shutdown; DOS OPL2
|
|
rhythm-mode snare on ch 7 with pitch via the hi-hat modulator and
|
|
a shared adlibFreqToFnum factored out of jlpAudioVoice; Amiga
|
|
1024-byte LFSR chip sample looped on Paula ch 3, mt_musicmask
|
|
re-applied after every mt_end; IIgs resident LFSR sample on SFX
|
|
slot 3 with retrigger phase rotation -- and a real guard fix:
|
|
jlpAudioVoice bounded by SFX_SLOTS could stamp tone squares over
|
|
slots 3-4). Sequencer v2: noise as uniform voice 3, tempo-change
|
|
opcode, jlMusicSetAtten fades, jlMusicPause/Resume. songbake v2:
|
|
noise column, repeat blocks, mid-song tickms, ST-overlap warning.
|
|
AGI's always-parsed-never-sounded SN76489 noise channel is now
|
|
audible via psgNoiseApply. Design recon = 10-agent workflow
|
|
(5 design + 5 adversarial verify) that caught 3 hardware-level
|
|
bugs pre-implementation. Gates: builds x4, AGI host suite 1/1,
|
|
sequencer host harness all-checks, golden 51/51 x4 cross-diff.
|
|
|
|
- 2026-07-20 (later): portable chip-tracker music layer landed (the
|
|
cross-platform answer to the ST MOD tax -- one authored song, four
|
|
native chip backends, no CPU mixing anywhere). New: src/core/music.c
|
|
jlMusicPlay/Stop/IsPlaying sequencer over the JYM1 event stream
|
|
(tools/songbake bakes text notation; pacing = jlMillisElapsed so
|
|
tempo holds at 50/60/70 Hz; pumped by jlAudioFrameTick above the
|
|
gAudioReady gate). Hunt-3 rank 4 landed as the IIgs backend:
|
|
jlpAudioVoice rewritten from synthesize-per-call (~120-150 ms: C
|
|
toneFill + forced 2 KB XOR recopy, plus it burned that cost even
|
|
with audio uninitialized) to a resident DOC-unsigned square with
|
|
freqWord/length/volume struct pokes + one NTPstreamsound JSL per
|
|
note (~10 far stores). Amiga jlpAudioVoice implemented for the
|
|
first time (was a stub): Paula ch 0-2 looping a 2-byte chip-RAM
|
|
square, DMA auto-reload sustains for free. Voices vs MOD stay
|
|
mutually exclusive on ST/Amiga (same chip). jlAudioFrameTick gains
|
|
a no-song boolean check (musicPump) -- DOS row 57969 ops/s,
|
|
unchanged within noise. Gates: 4-port builds clean, DOS/ST/Amiga/
|
|
IIgs golden 51/51 cross-diff OK.
|
|
|
|
- 2026-07-20: hunt-3 top ranks landed. Rank 1 probe re-baseline
|
|
(IIgs+ST -DUBER_PROBE battery): the IIgs gameFrameClean mystery SOLVED --
|
|
the split rows (newly wired into the IIgs timeOp arm) attributed the
|
|
28.6 ms as erases 15.9 + draws 3.3 + present 9.4, exposing
|
|
jlSurfaceCopyRect at ~5.3 ms PER 16x16 call: the Phase-7 C word-copy
|
|
override had regressed into the dead-lever-#12 shape (llvm-mos
|
|
re-deriving both far pointers per word, ~30+ instr/word, visible in
|
|
the current -S). Fix = iigsCopyRectRows asm ([dp],y pairs, ~21
|
|
cyc/word): gameFrameClean 35 -> 56 ops/s (+60%), hash C51FE171
|
|
unchanged, 51/51. Rank 5: jlpInputPoll idle clear memset ->
|
|
iigsByteFill: jlInputPoll 228 -> 662 ops/s (+190%). Rank 3: AGI
|
|
restoreRectFromBackdrop -> jlSurfaceCopyRect (the stale "planar =
|
|
rare (Amiga only)" fallback full-copied 32KB per object erase on
|
|
BOTH 68k ports and forced full-dirty presents); builds clean x4,
|
|
host AGI suite 1/1 (harness stub rot also repaired). Rank 2: rate
|
|
cards refreshed in place (IIgs base 2.75 ms, ST idle 0.87 ms, Amiga
|
|
idle 0.87 ms recorded for the first time, DOS 1.7 us/B model REFUTED
|
|
-- measured 29/s EXCEEDS the old ceiling, refit ~1.40 us/B; ST P2
|
|
RE-OPENED at ~775/s re-derived ceiling). IIgs probe battery also
|
|
refreshed: present96 26/s, present3win 133/s, trusted save 795/s,
|
|
drawTrusted 1262/s, shrParity OK, band fingerprints cross-port
|
|
identical.
|
|
- 2026-07-19: perf-hunt-2 close-out. Ranks 8/9/10/12/13/14/17 landed
|
|
(ST draw-JIT group rewrite: jlSpriteDraw 1366 -> 1807 +32%,
|
|
saveAndDraw +21%, gameFrameClean +14%; jlSpriteDrawTrusted on all
|
|
ports; IIgs fused save: saveUnder 602 -> 722 +20%; ST PS_ROW inline
|
|
arm; DOS inline-mark + full trusted family: safe restore +5%,
|
|
trusted restore +21%; Amiga fillCircle exact-disk walk 31 -> 40
|
|
+29%; cleanup batch incl. 115 lines of unreachable ST walkers).
|
|
Rank 11 v2 landed after a re-probe (presentScan.s 50-fixed-group
|
|
restructure; Amiga gameFrameClean 91 -> 97 +6.6%; the re-measured
|
|
split: scan 3.24 / flush 1.61 / flip 0.36 / residual 1.33 ms of a
|
|
6.54 ms present3win). Ranks 15/16 killed by their own gates. P7-2
|
|
stage 2 (metadata fills into a 10-arg asm entry) was built,
|
|
measured 722 -> 602, and REVERTED -- llvm-mos argument marshalling
|
|
costs more than the far stores it replaces (the fnAddr-cache wall;
|
|
P7-2 is closed, both directions measured). All landings 51/51
|
|
cross-port + P5/P11/P12 parity.
|
|
- 2026-07-13 (later): perf-hunt-2 ranks 2/4/5/6/7 landed. ST+Amiga
|
|
idle-present group scan (4 rows per longword vs the 0xFF clean
|
|
sentinel): jlStagePresent full ST 407 -> 1150/s, Amiga 609 ->
|
|
1131/s; composites unchanged. DOS: -fomit-frame-pointer (flag
|
|
parity; input rows +28-29%), 4-row group skip in jlpPresent (P8
|
|
idle 1137 -> 3881/s), dword-fused VGA expand (gameFrameClean 196 ->
|
|
243, gameFrame 19 -> 23), NEW P12 vgaMismatch display gate
|
|
(dosProbeVgaMismatch + UBER_PROBE battery, 0/0/0), and the
|
|
gameFrameClean component split (present 3.06 / erases 0.70 / draws
|
|
0.34 ms). All four ports 51/51 cross-diffed after each landing.
|
|
- 2026-07-13: IIgs dirty-band memset fix (perf-hunt-2 rank 1+3). The
|
|
"13.7 ms irreducible present base" was mostly two libc memset far
|
|
calls: stageDirtyClearAll (runs after EVERY present) memset both
|
|
200-byte band arrays, and llvm-mos lowers memset to `jsl memset` --
|
|
libc's `while (n--) *d++ = c` byte loop (the old "MVN-seeded"
|
|
comments were wrong; finding-#79 class). Replaced with asm word
|
|
fills in joeyDraw.s (iigsStageBandsClearAll / MarkAll, abs,x
|
|
descending; a C word-fill emitted ~35 instr/store and was rejected)
|
|
plus iigsByteFill ([dp],y) for jlScbSetRange. Measured (MAME):
|
|
jlStagePresent full 67 -> 363/s (fixed base ~13.7 -> ~2.75 ms),
|
|
jlScbSetRange 163 -> 1322/s, jlSurfaceClear 33 -> 56/s,
|
|
gameFrameClean 24 -> 35/s, gameFrame 12 -> 14/s. 51/51 golden vs
|
|
Amiga reference; verify-iigs UBER framebuffer checksum byte-
|
|
identical to the memset build. NOTE: every IIgs ceiling that bakes
|
|
in the 13.7 ms base (P1/P2 rows, assumption 4, the rate-card fixed
|
|
base) is now stale on the optimistic side for the library and needs
|
|
re-derivation with the ~2.75 ms base; the 2026-07-08 baseline table
|
|
rows for the five ops above are superseded by the numbers here.
|
|
- 2026-07-08: Phase 6 W1+W2+W3 landed (fused IIgs sprite/fillRect
|
|
entries + sprite-mark specialization; per-row/fused presents on
|
|
Amiga/ST/IIgs with display-parity probe gates P8-P11; ST movep tile
|
|
singles, DOS map walker, Amiga blitter copyRect + map hoist). Table
|
|
regenerated from a clean rebuild, 51/51 x4. Ceilings re-derived
|
|
from the measured models (fitted IIgs write cost, ST bus floor,
|
|
movep/blitter rates) -- the old ~29 ops/s IIgs full-screen note is
|
|
superseded in place.
|
|
|
|
Pre-2026-07-04 tables (ORCA-era IIgs column, artifact-inflated DOS
|
|
numbers, un-batched loops) live in git history only -- every
|
|
conclusion drawn from them was re-derived from Phase 0 onward. The
|
|
Phase 0 baseline (2026-07-04) and per-phase deltas are recorded in
|
|
PERF-AUDIT-PLAN.md's progress tracker; headline gains since Phase 0:
|
|
IIgs interpreted spriteDraw 18 -> 48 ops/sec (Phase 4), IIgs
|
|
tilePasteMono asm 3.35x (Phase 7 #3), ST flood plane hooks 5.6x
|
|
(Phase 7 #4), DOS paletteSet +92% / tileSnap +42% (Phases 2/5),
|
|
DOS compiled sprites 284 -> ~6100 ops/sec (#74).
|