SirRoboGarage/common_libs/tests/measure_tm_pattern_cost.nim

## MEASUREMENT ONLY — per-tick cost of the rack-registered TM pattern gun
## (id 14, radial mode) in isolation, following the `runPerGun` pattern of
## `measure_parallel_vbullet_cost.nim`.
##
## Drives ONE gun through a real DrussGT fixture with a one-gun VirtualTracker,
## timing `predict` (4 power bins/tick) and `onResult` (one call per resolved
## virtual bullet) separately, then reports ms/tick against the ~13.16 ms live
## budget (76 ticks/s). Tsetlin is measured the same way as the reference the
## brief quotes (~5.3 ms/tick).
##
## Usage:
##   nim c -r -d:release common_libs/tests/measure_tm_pattern_cost.nim

import std/[os, strformat, tables, math, times, monotimes, random]
import gun_harness/offline_range
import gun_harness/gun_interface
import gun_harness/virtual_bullets as vb
import guns/tm_pattern
import guns/tsetlin

const
  RepoRoot = currentSourcePath().parentDir.parentDir.parentDir
  FixturePath = RepoRoot / "tools" / "fixtures" / "tr_drussgt_vs_crazy.jsonl"

type
  CostResult = object
    predictNs:  int64
    onResultNs: int64
    ticks:      int
    predictCalls: int
    onCalls:    int

proc measureGun(fx: Fixture, predictCb: proc(state: WorldState, bulletSpeed: float): GunPrediction {.closure.},
                resultCb: proc(e: FeedbackEvent) {.closure.},
                metric: BulletMetric, warmup, measure: int): CostResult =
  var tracker = vb.initTracker(1, metric)
  let acc = new(CostResult)
  let ticks = fx.states.len
  for si in 0..<ticks:
    let state = fx.states[si]
    var preds: array[len(vb.PowerBins), GunPrediction]
    let t0 = getMonoTime()
    for b in 0..<len(vb.PowerBins):
      preds[b] = predictCb(state, bulletSpeed(vb.PowerBins[b]))
    let t1 = getMonoTime()
    tracker.spawnBullets(0, preds, state, fx.enemyId)

    var enemyPositions: Table[int, tuple[x, y: float, lastSeenTick: int, alive: bool]]
    enemyPositions[fx.enemyId] = (x: state.enemyX, y: state.enemyY,
                                  lastSeenTick: state.tick, alive: true)
    tracker.tickBullets(state, enemyPositions,
      proc(gunId: GunId, binIdx: int, e: FeedbackEvent) =
        let s0 = getMonoTime()
        resultCb(e)
        let s1 = getMonoTime()
        if si >= warmup and si < warmup + measure:
          acc.onResultNs += (s1 - s0).inNanoseconds
          inc acc.onCalls)
    if si >= warmup and si < warmup + measure:
      inc acc.ticks
      acc.predictNs += (t1 - t0).inNanoseconds
      inc acc.predictCalls, len(vb.PowerBins)
  result = acc[]

proc makeTmRadial(fx: Fixture, metric: BulletMetric, warmup, measure: int): CostResult =
  let g = new(TmPatternGun)
  g[] = initTmRadialGun()
  randomize(1)
  result = measureGun(fx,
    proc(state: WorldState, bulletSpeed: float): GunPrediction = g[].predict(state, bulletSpeed),
    proc(e: FeedbackEvent) = g[].onResult(e),
    metric, warmup, measure)
  echo fmt"  TMPattern(radial): obs={g[].totalObs} labelMiss={g[].labelMisses} " &
       fmt"traceMiss={g[].traceMisses} radAcc={g[].radCorrect}/{g[].radTotal}"
  var lab = ""
  var maj = 0
  var tot = 0
  for c in 0..<TM_CLASSES:
    lab.add $g[].radLabelHist[c] & " "
    maj = max(maj, g[].radLabelHist[c])
    tot += g[].radLabelHist[c]
  echo fmt"    radial label hist [{lab}]  majority={maj.float / max(1, tot).float * 100:.1f}%  pendingDropped={g[].pendingDropped}"

proc makeTsetlin(fx: Fixture, metric: BulletMetric, warmup, measure: int): CostResult =
  let g = new(TsetlinGun)
  g[] = initTsetlinGun()
  randomize(1)
  result = measureGun(fx,
    proc(state: WorldState, bulletSpeed: float): GunPrediction = g[].predict(state, bulletSpeed),
    proc(e: FeedbackEvent) = g[].onResult(e),
    metric, warmup, measure)

proc main() =
  if not fileExists(FixturePath):
    echo "fixture missing: ", FixturePath
    quit(1)
  let fx = loadFixture(FixturePath)
  echo fmt"fixture: {fx.meta.adversary} ticks={fx.states.len} metric=point"

  const Warmup = 150
  const Measure = 800
  const BudgetMs = 1000.0 / 76.0   # ~76 ticks/s measured bridge throughput
  echo fmt"warmup={Warmup} measured={Measure} ticks; budget={BudgetMs:.2f} ms/tick"
  echo ""

  let tm = makeTmRadial(fx, bmPoint, Warmup, Measure)
  let ts = makeTsetlin(fx, bmPoint, Warmup, Measure)

  proc report(name: string, r: CostResult) =
    let pMs = r.predictNs.float / 1.0e6 / max(1, r.ticks).float
    let oMs = r.onResultNs.float / 1.0e6 / max(1, r.ticks).float
    let tot = pMs + oMs
    echo fmt"{name:<18} predict {pMs:6.2f} ms/tick  onResult {oMs:6.2f} ms/tick  " &
         fmt"total {tot:6.2f} ms/tick ({tot / BudgetMs * 100:5.0f}% budget)  " &
         fmt"onCalls/tick={r.onCalls.float / max(1, r.ticks).float:.1f}"

  echo "=================== PER-TICK COST (single gun, bmPoint) ==================="
  report("TMPattern(radial)", tm)
  report("Tsetlin (reference)", ts)

  # ── pooled radial-head learning stats over the real fixture set ─────────────
  const RealFixtures = ["drussgt_vs_crazy", "drussgt_vs_spinbot",
    "drussgt_vs_drussgt", "tr_drussgt_vs_crazy", "tr_drussgt_vs_spinbot",
    "tr_drussgt_vs_modularbot"]
  echo ""
  echo "=================== POOLED RADIAL HEAD (real fixtures, bmPoint) ==================="
  var realHist: array[TM_CLASSES, int]
  var realChosen: array[TM_CLASSES, int]
  var realCorrect, realTotal = 0
  var shufHist: array[TM_CLASSES, int]
  var shufChosen: array[TM_CLASSES, int]
  var shufCorrect, shufTotal = 0
  for name in RealFixtures:
    let p = RepoRoot / "tools" / "fixtures" / (name & ".jsonl")
    if not fileExists(p): continue
    let f = loadFixture(p)
    block:
      let g = new(TmPatternGun)
      g[] = initTmRadialGun()
      randomize(1)
      discard measureGun(f,
        proc(state: WorldState, bulletSpeed: float): GunPrediction = g[].predict(state, bulletSpeed),
        proc(e: FeedbackEvent) = g[].onResult(e), bmPoint, 0, 0)
      realCorrect += g[].radCorrect
      realTotal += g[].radTotal
      for c in 0..<TM_CLASSES: realHist[c] += g[].radLabelHist[c]
      for c in 0..<TM_CLASSES: realChosen[c] += g[].radChosenHist[c]
    block:
      let g = new(TmPatternGun)
      g[] = initTmRadialGun()
      g[].shuffleLabels = true
      randomize(1)
      discard measureGun(f,
        proc(state: WorldState, bulletSpeed: float): GunPrediction = g[].predict(state, bulletSpeed),
        proc(e: FeedbackEvent) = g[].onResult(e), bmPoint, 0, 0)
      shufCorrect += g[].radCorrect
      shufTotal += g[].radTotal
      for c in 0..<TM_CLASSES: shufHist[c] += g[].radLabelHist[c]
      for c in 0..<TM_CLASSES: shufChosen[c] += g[].radChosenHist[c]
  var realMaj, shufMaj, realN, shufN = 0
  var rs, ss, rc, sc = ""
  for c in 0..<TM_CLASSES:
    realMaj = max(realMaj, realHist[c]); realN += realHist[c]
    shufMaj = max(shufMaj, shufHist[c]); shufN += shufHist[c]
    rs.add $realHist[c] & " "
    ss.add $shufHist[c] & " "
    rc.add $realChosen[c] & " "
    sc.add $shufChosen[c] & " "
  echo fmt"  real:     radAcc={realCorrect}/{realTotal} = {realCorrect.float/max(1,realTotal).float*100:.1f}%  " &
       fmt"majority={realMaj.float/max(1,realN).float*100:.1f}%  labels=[{rs}] chosen=[{rc}]"
  echo fmt"  shuffled: radAcc={shufCorrect}/{shufTotal} = {shufCorrect.float/max(1,shufTotal).float*100:.1f}%  " &
       fmt"majority={shufMaj.float/max(1,shufN).float*100:.1f}%  labels=[{ss}] chosen=[{sc}]"

when isMainModule:
  main()