#!/usr/bin/env python3
"""What does spending the idle bus bandwidth buy back in CPU cycles?

    python3 tools/analysis/12_span_tradeoff.py [container.dlx] [--bus 488]

FINDINGS 28 leaves the decoder CPU-bound at 110 KB/s on a 488 KB/s pipe. Every
codec decision was made when bytes were scarce, so each one trades cycles to
save them -- and the cheapest thing a 68000 can be handed is the most expensive
thing to store: word-expanded pixels in row-linear runs.

This prices ONE new mode against the real mode maps: a per-row SPAN of
word-expanded literals, `movem.l`-ed straight from the stream buffer into GVRAM.
A run of L horizontally adjacent dirty blocks becomes 4 spans of 4L pixels.

DERIVED, NOT MEASURED (FINDINGS 29). The 9.08 cycles/pixel is measured
(FINDINGS 24 V1) but at full row width with 12-register bursts; SPAN_OVERHEAD is
hand-derived. Short spans are therefore flattered. Measure before believing --
FINDINGS 29.5 item 1.

The mode maps are NOT re-optimised: this only re-codes regions the encoder
already chose to redraw, so it is a lower bound on what a cost-aware encoder
would find.
"""
import sys, os, argparse
sys.path.insert(0, "tools/encoder")
import numpy as np
from dlx import DLX

FRAME_CYC = 833333.0                      # 12fps at 10 MHz
AUDIO_KBPS = 7.8

CYC_PX_ROWLIN = 446286 / 49152.           # 9.08, FINDINGS 24 V1 (measured)
C_V1, C_V4, C_RAW = 299.9, 448.2, 400.4   # FINDINGS 28.2 (measured)
C_SKIP_CLUSTERED, C_SKIP_MIXED = 13.25, 45.0
SPAN_OVERHEAD = 50.0                      # per span, DERIVED
SPAN_BYTES_PX = 2                         # word-expanded: 1 pixel = 1 word
SPAN_HDR = 3                              # x, count, and a byte of slack

ap = argparse.ArgumentParser()
ap.add_argument("container", nargs="?",
                default="tmp/rc_fr_singe_sasi_rcprofile.dlx")
ap.add_argument("--bus", type=float, default=488.0,
                help="sustained KB/s the pipe delivers (FINDINGS 21)")
ap.add_argument("--fps", type=float, default=12.0)
a = ap.parse_args()
if not os.path.exists(a.container):
    sys.exit(f"missing {a.container}")

BYTE_BUD = (a.bus - AUDIO_KBPS) * 1024 / a.fps
d = DLX(a.container)
BLK_C = {1: C_V1, 2: C_V4, 3: C_RAW}
BLK_B = {1: 1, 2: 4, 3: 16}

rows = []
for f in range(d.nframes):
    mode = d.modes(f)
    g = mode.reshape(-1, 4)
    allskip = (g == 0).all(1)
    base = allskip.sum() * 4 * C_SKIP_CLUSTERED
    mm = g[~allskip]
    base += (mm == 0).sum() * C_SKIP_MIXED
    for k, c in BLK_C.items():
        base += (mm == k).sum() * c
    base_b = d.mode_bytes + sum(BLK_B.get(int(x), 0) for x in mode)

    m = mode.reshape(d.nby, d.nbx)
    cand = []
    for by in range(d.nby):
        dirty = m[by] != 0
        i = 0
        while i < d.nbx:
            if not dirty[i]:
                i += 1
                continue
            j = i
            while j < d.nbx and dirty[j]:
                j += 1
            L = j - i
            cur_c = sum(BLK_C[int(b)] for b in m[by][i:j])
            cur_b = sum(BLK_B[int(b)] for b in m[by][i:j])
            span_c = 4 * (SPAN_OVERHEAD + 4 * L * CYC_PX_ROWLIN)
            span_b = 4 * (SPAN_HDR + 4 * L * SPAN_BYTES_PX)
            if span_c < cur_c:
                cand.append((cur_c - span_c, span_b - cur_b, L))
            i = j

    cand.sort(key=lambda s: -(s[0] / max(s[1], 1)))     # best cycles per byte
    cyc, byt, taken = base, base_b, 0
    for dc, db, L in cand:
        if byt + db <= BYTE_BUD:
            cyc -= dc; byt += db; taken += 1
    rows.append((base, cyc, base_b, byt, len(cand), taken))

base, new, bb, nb, ncand, ntaken = map(np.array, list(zip(*rows)))
pc = lambda v: 100 * v / FRAME_CYC

print(f"{a.container}: {d.nframes} frames")
print(f"bus {a.bus:.0f} KB/s - {AUDIO_KBPS} audio -> {BYTE_BUD:,.0f} B/frame "
      f"at {a.fps:g}fps\n")
print(f"{'':<26}{'today':>12}{'+ literal spans':>18}")
for label, fn in (("median frame", np.median),
                  ("p90 frame", lambda v: np.percentile(v, 90)),
                  ("worst frame", np.max)):
    print(f"  {label:<24}{pc(fn(base)):>11.1f}%{pc(fn(new)):>17.1f}%")
print(f"  {'frames missing budget':<24}{int((base>FRAME_CYC).sum()):>8}/{d.nframes}"
      f"{int((new>FRAME_CYC).sum()):>14}/{d.nframes}")
print(f"  {'bitrate':<24}{bb.mean()*a.fps/1024:>10.1f} KB/s"
      f"{nb.mean()*a.fps/1024:>13.1f} KB/s")
print(f"\nspans taken: {ntaken.sum()} of {ncand.sum()} candidate runs "
      f"({100*ntaken.sum()/max(ncand.sum(),1):.0f}%) -- the rest priced out by the bus")
print("\nDERIVED, NOT MEASURED: see FINDINGS 29.5 before acting on this.")