bobframes 0.1.0__py3-none-any.whl

bobframes/reports/trend_table.py

@@ -0,0 +1,444 @@
+"""Trend table: per-area KPI matrices across drop_dates.
+
+One <h2> per KPI, rows = area, columns = drop_dates (+ delta cols + sparkline).
+Plus per-area class-count matrix at the end.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from collections import defaultdict
+
+import pyarrow.parquet as papq
+
+from . import base
+
+
+# (col_name, label, fmt, lower_is_better, regression_pct)
+KPIS = [
+    ('total_gpu_duration_s',          'gpu (s)',           '{:+,.3f}', True,  10.0),
+    ('n_draws',                        'draws',             '{:+,.0f}', True,  10.0),
+    ('vbo_bytes_bound_derived',        'vbo bytes',         '{:+,.0f}', True,  15.0),
+    ('ibo_bytes_bound_derived',        'ibo bytes',         '{:+,.0f}', True,  15.0),
+    ('program_switches',               'prog switches',     '{:+,.0f}', True,  20.0),
+]
+
+_INT_KPIS = {'n_draws', 'vbo_bytes_bound_derived', 'ibo_bytes_bound_derived',
+             'program_switches'}
+
+
+def _aggregate_frame_totals(drop: base.DropSet, ok_caps: set) -> dict:
+    """Return {area: {kpi: sum}} from frame_totals.parquet."""
+    out: dict = defaultdict(lambda: defaultdict(float))
+    for r in drop.rows:
+        p = os.path.join(r.drop_dir, 'frame_totals.parquet')
+        if not os.path.exists(p):
+            continue
+        try:
+            t = papq.read_table(p)
+        except Exception:
+            continue
+        cols = {c: t.column(c).to_pylist() for c in t.column_names}
+        for i in range(t.num_rows):
+            cap = cols['capture'][i]
+            key = (r.area, r.drop_date, r.drop_label, cap)
+            if ok_caps and key not in ok_caps:
+                continue
+            for kpi, *_ in KPIS:
+                if kpi in cols:
+                    v = cols[kpi][i]
+                    if v is not None:
+                        out[r.area][kpi] += v
+    return out
+
+
+def _aggregate_buffer_bytes(drop: base.DropSet, ok_caps: set) -> dict:
+    """Return {area: {vbo_bytes_bound_derived, ibo_..., ubo_...}}.
+
+    Buffer used_as_* flags are unpopulated (parser limitation).
+    Derive via joins:
+      vbo_bytes = sum allocated_size_bytes of distinct buffer_ids in vertex_inputs
+      ibo_bytes = sum allocated_size_bytes of distinct ibo_ids in draws
+      ubo_bytes = sum allocated_size_bytes of distinct resource_ids in
+                  draw_bindings where slot_kind='ubo'
+    """
+    out: dict = defaultdict(lambda: defaultdict(int))
+
+    for r in drop.rows:
+        ao = r.drop_dir
+
+        bufs_p = os.path.join(ao, 'buffers.parquet')
+        if not os.path.exists(bufs_p):
+            continue
+        try:
+            bt = papq.read_table(bufs_p,
+                                  columns=['capture', 'buffer_id', 'allocated_size_bytes'])
+        except Exception:
+            continue
+        bc = {n: bt.column(n).to_pylist() for n in bt.column_names}
+        size_by: dict[tuple, int] = {}
+        for i in range(bt.num_rows):
+            size_by[(bc['capture'][i], bc['buffer_id'][i])] = bc['allocated_size_bytes'][i] or 0
+
+        # vbo via vertex_inputs
+        vi_p = os.path.join(ao, 'vertex_inputs.parquet')
+        if os.path.exists(vi_p):
+            try:
+                vi = papq.read_table(vi_p, columns=['capture', 'buffer_id'])
+            except Exception:
+                vi = None
+            if vi is not None:
+                seen: set = set()
+                vc = {n: vi.column(n).to_pylist() for n in vi.column_names}
+                for i in range(vi.num_rows):
+                    cap = vc['capture'][i]
+                    bid = vc['buffer_id'][i]
+                    if not bid:
+                        continue
+                    key = (r.area, r.drop_date, r.drop_label, cap)
+                    if ok_caps and key not in ok_caps:
+                        continue
+                    pk = (r.area, cap, bid)
+                    if pk in seen:
+                        continue
+                    seen.add(pk)
+                    out[r.area]['vbo_bytes_bound_derived'] += size_by.get((cap, bid), 0)
+
+        # ibo via draws.ibo_id
+        draws_p = os.path.join(ao, 'draws.parquet')
+        if os.path.exists(draws_p):
+            try:
+                schema_cols = set(papq.read_schema(draws_p).names)
+                want = ['capture', 'ibo_id'] if 'ibo_id' in schema_cols else None
+                if want:
+                    dt = papq.read_table(draws_p, columns=want)
+                else:
+                    dt = None
+            except Exception:
+                dt = None
+            if dt is not None:
+                seen = set()
+                dc = {n: dt.column(n).to_pylist() for n in dt.column_names}
+                for i in range(dt.num_rows):
+                    cap = dc['capture'][i]
+                    ibo = dc['ibo_id'][i]
+                    if not ibo:
+                        continue
+                    key = (r.area, r.drop_date, r.drop_label, cap)
+                    if ok_caps and key not in ok_caps:
+                        continue
+                    pk = (r.area, cap, ibo)
+                    if pk in seen:
+                        continue
+                    seen.add(pk)
+                    out[r.area]['ibo_bytes_bound_derived'] += size_by.get((cap, ibo), 0)
+
+        # ubo via draw_bindings where slot_kind='ubo'
+        db_p = os.path.join(ao, 'draw_bindings.parquet')
+        if os.path.exists(db_p):
+            try:
+                db = papq.read_table(db_p,
+                                      columns=['capture', 'slot_kind', 'resource_id'])
+            except Exception:
+                db = None
+            if db is not None:
+                seen = set()
+                dbc = {n: db.column(n).to_pylist() for n in db.column_names}
+                for i in range(db.num_rows):
+                    if dbc['slot_kind'][i] != 'ubo':
+                        continue
+                    cap = dbc['capture'][i]
+                    rid = dbc['resource_id'][i]
+                    if not rid:
+                        continue
+                    key = (r.area, r.drop_date, r.drop_label, cap)
+                    if ok_caps and key not in ok_caps:
+                        continue
+                    pk = (r.area, cap, rid)
+                    if pk in seen:
+                        continue
+                    seen.add(pk)
+                    out[r.area]['ubo_bytes_bound_derived'] += size_by.get((cap, rid), 0)
+
+    return out
+
+
+def _aggregate_class_counts(drop: base.DropSet, ok_caps: set) -> dict:
+    """Return {area: {draw_class: n_draws}}."""
+    out: dict = defaultdict(lambda: defaultdict(int))
+    for r in drop.rows:
+        p = os.path.join(r.drop_dir, 'pass_class_breakdown.parquet')
+        if not os.path.exists(p):
+            continue
+        try:
+            t = papq.read_table(p, columns=['capture', 'draw_class', 'n_draws'])
+        except Exception:
+            continue
+        c = {n: t.column(n).to_pylist() for n in t.column_names}
+        for i in range(t.num_rows):
+            cap = c['capture'][i]
+            key = (r.area, r.drop_date, r.drop_label, cap)
+            if ok_caps and key not in ok_caps:
+                continue
+            cls = c['draw_class'][i] or 'other'
+            out[r.area][cls] += c['n_draws'][i] or 0
+    return out
+
+
+def _device_string(drop: base.DropSet) -> str:
+    for r in drop.rows:
+        p = os.path.join(r.drop_dir, 'frame_metadata.jsonl')
+        if not os.path.exists(p):
+            continue
+        try:
+            with open(p, 'r', encoding='utf-8') as f:
+                for line in f:
+                    try:
+                        o = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    s = o.get('gl_renderer_string') or o.get('gl_renderer') or ''
+                    if s:
+                        return s
+        except OSError:
+            continue
+    return ''
+
+
+def _kpi_matrix(kpi: str, label: str, fmt: str, lower_is_better, threshold,
+                per_drop_area_data: list, areas: list, drops: list) -> str:
+    """Render one KPI matrix as h2 + table-wrap (one per KPI when n_drops >= 2)."""
+    is_int = kpi in _INT_KPIS
+
+    parts = []
+    parts.append(f'<rdc-sticky-h2><h2 id="{base.h(kpi)}">{base.h(label)}</h2></rdc-sticky-h2>')
+    parts.append('<div class="table-wrap"><rdc-sortable-table>')
+    parts.append('<table class="report"><thead><tr>')
+    parts.append('<th>area</th>')
+    n_drops = len(drops)
+    for i, d in enumerate(drops):
+        parts.append(f'<th class="num">{base.h(d.key)}</th>')
+        if i > 0:
+            latest_cls = ' delta-latest' if i == n_drops - 1 else ''
+            parts.append(f'<th class="num{latest_cls}">delta</th>')
+    if n_drops >= 3:
+        parts.append('<th class="num">trend</th>')
+    parts.append('</tr></thead><tbody>')
+
+    for area in areas:
+        parts.append('<tr>')
+        parts.append(f'<td>{base.h(area)}</td>')
+        series: list = []
+        prev = None
+        for i, d in enumerate(drops):
+            v = per_drop_area_data[i].get(area, {}).get(kpi)
+            series.append(v)
+            if is_int:
+                parts.append(f'<td class="num">{base.fmt_int(v)}</td>')
+            else:
+                parts.append(f'<td class="num">{base.fmt_float(v, 3)}</td>')
+            if i > 0:
+                cell = base.delta_cell(
+                    v, prev,
+                    lower_is_better=lower_is_better,
+                    fmt=fmt,
+                    regression_threshold_pct=threshold,
+                )
+                if i == n_drops - 1:
+                    cell = cell.replace('class="delta', 'class="delta delta-latest', 1)
+                parts.append(cell)
+            prev = v
+        if n_drops >= 3:
+            parts.append(f'<td class="num">{base.sparkline_svg(series)}</td>')
+        parts.append('</tr>')
+    parts.append('</tbody></table></rdc-sortable-table></div>')
+    return '\n'.join(parts)
+
+
+def _single_drop_matrix(per_drop_ft: list, areas: list, drops: list) -> str:
+    """Render single wide matrix (rows=area, cols=KPI) when n_drops==1."""
+    parts = []
+    parts.append('<h2 id="matrix">per-area kpi matrix</h2>')
+    parts.append('<div class="table-wrap"><rdc-sortable-table>')
+    parts.append('<table class="report"><thead><tr>')
+    parts.append('<th>area</th>')
+    for kpi, label, *_ in KPIS:
+        parts.append(f'<th class="num">{base.h(label)}</th>')
+    parts.append('</tr></thead><tbody>')
+    data = per_drop_ft[0]
+    # Precompute per-column max for heatmap normalization
+    col_max: dict = {}
+    for kpi, _, _, _, _ in KPIS:
+        vals = [float(data.get(a, {}).get(kpi) or 0) for a in areas]
+        col_max[kpi] = max(vals) if vals else 0.0
+    for area in areas:
+        parts.append('<tr>')
+        parts.append(f'<td>{base.h(area)}</td>')
+        for kpi, _, _, _, _ in KPIS:
+            v = data.get(area, {}).get(kpi)
+            cmax = col_max[kpi]
+            if kpi in _INT_KPIS:
+                val_str = base.fmt_int(v)
+            else:
+                val_str = base.fmt_float(v, 3)
+            if v is not None and cmax > 0:
+                parts.append(
+                    f'<td class="num"><rdc-heatmap-cell data-value="{v}" '
+                    f'data-min="0" data-max="{cmax}" data-direction="hot">'
+                    f'{val_str}</rdc-heatmap-cell></td>'
+                )
+            else:
+                parts.append(f'<td class="num">{val_str}</td>')
+        parts.append('</tr>')
+    parts.append('</tbody></table></rdc-sortable-table></div>')
+    return '\n'.join(parts)
+
+
+def _class_count_matrix(per_drop_area_class: list, areas: list,
+                        drops: list) -> str:
+    parts = []
+    parts.append('<rdc-sticky-h2><h2 id="class_counts">draws by class</h2></rdc-sticky-h2>')
+    parts.append('<div class="table-wrap"><rdc-sortable-table>')
+    parts.append('<table class="report"><thead><tr>')
+    parts.append('<th>area</th>')
+    single = len(drops) == 1
+    for d in drops:
+        for cls in base.DRAW_CLASSES:
+            head = base.h(cls) if single else f'{base.h(d.key)}/{base.h(cls)}'
+            parts.append(f'<th class="num">{head}</th>')
+    parts.append('</tr></thead><tbody>')
+    for area in areas:
+        parts.append('<tr>')
+        parts.append(f'<td>{base.h(area)}</td>')
+        for i in range(len(drops)):
+            cc = per_drop_area_class[i].get(area, {})
+            for cls in base.DRAW_CLASSES:
+                parts.append(f'<td class="num">{base.fmt_int(cc.get(cls, 0))}</td>')
+        parts.append('</tr>')
+    parts.append('</tbody></table></rdc-sortable-table></div>')
+    return '\n'.join(parts)
+
+
+def build(root: str, *, drops: list | None = None, ab=None) -> str:
+    if drops is None:
+        drops = base.discover_drops(root)
+    if not drops:
+        out_path = base.output_path(root, 'trend_table', ab)
+        with open(out_path, 'w', encoding='utf-8') as f:
+            f.write(base.page_open('trend table'))
+            f.write(base.header('trend table', drops=0, captures=0,
+                                build_ts=base.now_iso()))
+            f.write('<p class="note">no drops found in catalog</p>')
+            f.write(base.page_close())
+        base._lint_or_raise(out_path)
+        return out_path
+
+    ok_caps = base.ok_capture_set(root)
+
+    per_drop_ft = []
+    per_drop_bytes = []
+    per_drop_class = []
+    device_strings = []
+    for d in drops:
+        ft = _aggregate_frame_totals(d, ok_caps)
+        bb = _aggregate_buffer_bytes(d, ok_caps)
+        for area in list(ft.keys()) + list(bb.keys()):
+            ft.setdefault(area, {})
+            ft[area].update(bb.get(area, {}))
+        per_drop_ft.append(ft)
+        per_drop_bytes.append(bb)
+        per_drop_class.append(_aggregate_class_counts(d, ok_caps))
+        device_strings.append(_device_string(d))
+
+    all_areas = sorted({a for d in per_drop_ft for a in d.keys()})
+    drop_keys_l = [d.key for d in drops]
+
+    body_attrs = {'data-multi-section': 'true'} if len(drops) > 1 else None
+    parts = [base.page_open('trend table', hdr_offset_px=120, body_attrs=body_attrs)]
+    parts.append(base.header(
+        'trend table',
+        drops=len(drops),
+        captures=sum(d.n_captures for d in drops),
+        build_ts=base.now_iso(),
+        crumb_depth=base.crumb_depth(ab),
+    ))
+    if ab is not None:
+        baseline, compare = ab
+        parts.append(base.ab_strip(
+            ab,
+            baseline_suffix=f' ({baseline.n_captures} captures)',
+            compare_suffix=f' ({compare.n_captures} captures)',
+        ))
+    parts.append(base.ab_picker_for(root, 'trend_table', ab=ab))
+
+    # Summary bar: worst KPI (n=1) or biggest regression (n>1)
+    if len(drops) == 1:
+        ft = per_drop_ft[0]
+        worst_area, worst_gpu = None, 0.0
+        for area, kpis in ft.items():
+            g = float(kpis.get('total_gpu_duration_s', 0) or 0)
+            if g > worst_gpu:
+                worst_gpu, worst_area = g, area
+        if worst_area is not None:
+            parts.append(base.summary_bar(
+                'worst gpu area',
+                worst_area,
+                sub=f'rank 1 of {len(all_areas)} areas',
+                tone='neutral',
+            ))
+    else:
+        worst_pct = 0.0
+        worst_tuple = None
+        for kpi, label, *_rest in KPIS:
+            for area in all_areas:
+                prev = None
+                for di, drop in enumerate(drops):
+                    cur = per_drop_ft[di].get(area, {}).get(kpi)
+                    if cur is None:
+                        continue
+                    if prev is not None and prev > 0:
+                        pct = 100.0 * (float(cur) - float(prev)) / float(prev)
+                        if pct > worst_pct:
+                            worst_pct = pct
+                            worst_tuple = (area, label, pct, drops[di-1].key, drop.key)
+                    prev = cur
+        if worst_tuple is not None:
+            area, label, pct, prev_key, cur_key = worst_tuple
+            tone = 'alarm' if pct >= 10.0 else 'warn'
+            parts.append(base.summary_bar(
+                'biggest regression',
+                f'{area} / {label} +{base.fmt_float(pct, 1)}%',
+                sub=f'{prev_key} to {cur_key}',
+                tone=tone,
+            ))
+
+    if any(device_strings):
+        chips = []
+        for d, dev in zip(drops, device_strings):
+            chips.append(f'{base.h(d.key)}: {base.safe_chrome_text(dev) or "no metadata"}')
+        parts.append(f'<div class="device-strip">{" | ".join(chips)}</div>')
+
+    if len(drops) == 1:
+        parts.append(_single_drop_matrix(per_drop_ft, all_areas, drops))
+    else:
+        parts.append('<nav class="toc">')
+        for kpi, label, *_ in KPIS:
+            parts.append(f'<a href="#{base.h(kpi)}" data-link-kind="crumb">{base.h(label)}</a>')
+        parts.append('<a href="#class_counts" data-link-kind="crumb">draws by class</a>')
+        parts.append('</nav>')
+        for kpi, label, fmt, lib, thr in KPIS:
+            parts.append(_kpi_matrix(kpi, label, fmt, lib, thr,
+                                      per_drop_ft, all_areas, drops))
+
+    parts.append(_class_count_matrix(per_drop_class, all_areas, drops))
+
+    parts.append(base.page_close())
+
+    out_path = base.output_path(root, 'trend_table', ab)
+    return base.write_report(out_path, parts)
+
+
+if __name__ == '__main__':
+    sys.exit(base.run_report(build, module_name='trend_table'))

bobframes/resource_labels.py

@@ -0,0 +1,162 @@
+"""Build _resource_labels.json sidecar from per-capture stage labels + Parquet.
+
+The HTML browser reads this file and enriches ID columns at render time so
+e.g. `tex_id=2184` shows as `2184 SceneDepthZ`.
+
+Structure on disk:
+{
+  "by_capture": {
+    "1": {
+      "texture":   {"2184": "SceneDepthZ", ...},
+      "shader":    {"2192": "compute 224B hash:39013910"},
+      "program":   {"2193": "vs:2192 fs:0"},
+      "sampler":   {"116": "..."},
+      "fbo":       {"...": "..."},
+      "buffer":    {"...": "..."}
+    }
+  }
+}
+
+`build_from_stage` runs at merge time when _stage/<cap>/labels.json + the
+already-merged Parquet files are both present.
+
+`build_from_outdir` rebuilds from an existing _analysis_out/ (when no
+stage is available, e.g. --render-only mode).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Iterable
+
+import pyarrow.parquet as papq
+
+
+def _short_name_for_shader(shader_row: dict) -> str:
+    stype = shader_row.get('shader_type', '') or ''
+    src_len = int(shader_row.get('src_len', 0) or 0)
+    h = shader_row.get('src_hash', '') or ''
+    samples = int(shader_row.get('total_texture_samples', 0) or 0)
+    branches = int(shader_row.get('total_branches', 0) or 0)
+    loops = int(shader_row.get('total_loops', 0) or 0)
+    bits = []
+    if stype: bits.append(stype)
+    if src_len: bits.append(f'{src_len}B')
+    if h: bits.append(f'h:{h[:8]}')
+    if samples: bits.append(f'tex={samples}')
+    if branches: bits.append(f'br={branches}')
+    if loops: bits.append(f'lo={loops}')
+    return ' '.join(bits)
+
+
+def _short_name_for_program(prog_row: dict, shader_names: dict[int, str]) -> str:
+    vs = int(prog_row.get('vs_shader_id', 0) or 0)
+    fs = int(prog_row.get('fs_shader_id', 0) or 0)
+    cs = int(prog_row.get('cs_shader_id', 0) or 0)
+    bits = []
+    if vs: bits.append(f'vs:{vs}')
+    if fs: bits.append(f'fs:{fs}')
+    if cs: bits.append(f'cs:{cs}')
+    n_uniforms = int(prog_row.get('num_active_uniforms', 0) or 0)
+    if n_uniforms: bits.append(f'u={n_uniforms}')
+    return ' '.join(bits)
+
+
+def _per_capture_from_parquet(out_dir: str) -> dict[str, dict[str, dict[str, str]]]:
+    """Read the drop's Parquet files and build per-capture label maps.
+
+    Pulls glObjectLabel-supplied names from textures/programs/samplers/fbos
+    columns, and synthesizes names for shaders + programs without labels.
+    """
+    by_cap: dict[str, dict[str, dict[str, str]]] = {}
+
+    def _bag(cap: str) -> dict[str, dict[str, str]]:
+        return by_cap.setdefault(cap, {
+            'texture': {}, 'shader': {}, 'program': {},
+            'sampler': {}, 'fbo': {}, 'buffer': {},
+        })
+
+    def _read(table: str, id_col: str, label_col: str, kind: str) -> None:
+        p = os.path.join(out_dir, f'{table}.parquet')
+        if not os.path.exists(p):
+            return
+        cols = list(papq.read_schema(p).names)
+        want = ['capture', id_col]
+        if label_col in cols:
+            want.append(label_col)
+        try:
+            t = papq.read_table(p, columns=want)
+        except Exception:
+            return
+        cap_arr = t.column('capture').to_pylist()
+        id_arr = t.column(id_col).to_pylist()
+        lab_arr = t.column(label_col).to_pylist() if label_col in cols else [''] * t.num_rows
+        for c, i, l in zip(cap_arr, id_arr, lab_arr):
+            if not i:
+                continue
+            sid = str(i)
+            if l:
+                _bag(c)[kind][sid] = l
+
+    _read('textures', 'tex_id', 'label', 'texture')
+    _read('render_targets', 'rt_id', 'label', 'texture')  # RTs go into texture bucket
+    _read('programs', 'program_id', 'label', 'program')
+    _read('samplers', 'sampler_id', 'label', 'sampler')
+    _read('fbos', 'fbo_id', 'label', 'fbo')
+
+    # Synthesize shader names from shaders.parquet
+    sh_path = os.path.join(out_dir, 'shaders.parquet')
+    if os.path.exists(sh_path):
+        t = papq.read_table(sh_path)
+        cols = t.column_names
+        idx = {c: t.column(c).to_pylist() for c in cols}
+        n = t.num_rows
+        for i in range(n):
+            cap = idx['capture'][i]
+            sid = idx['shader_id'][i]
+            if not sid:
+                continue
+            row = {c: idx[c][i] for c in cols}
+            name = _short_name_for_shader(row)
+            if name:
+                _bag(cap)['shader'][str(sid)] = name
+
+    # Synthesize program "name" (vs:N fs:M) if no glObjectLabel name set
+    pr_path = os.path.join(out_dir, 'programs.parquet')
+    if os.path.exists(pr_path):
+        t = papq.read_table(pr_path)
+        cols = t.column_names
+        idx = {c: t.column(c).to_pylist() for c in cols}
+        n = t.num_rows
+        for i in range(n):
+            cap = idx['capture'][i]
+            pid = idx['program_id'][i]
+            if not pid:
+                continue
+            existing = _bag(cap)['program'].get(str(pid), '')
+            if existing:
+                continue
+            row = {c: idx[c][i] for c in cols}
+            sname = _short_name_for_program(row, {})
+            if sname:
+                _bag(cap)['program'][str(pid)] = sname
+
+    return by_cap
+
+
+def write_resource_labels(out_dir: str) -> str:
+    """Read _analysis_out/*.parquet, produce _resource_labels.json sidecar."""
+    by_cap = _per_capture_from_parquet(out_dir)
+    path = os.path.join(out_dir, '_resource_labels.json')
+    with open(path, 'w', encoding='utf-8') as f:
+        json.dump({'by_capture': by_cap}, f, separators=(',', ':'))
+    return path
+
+
+if __name__ == '__main__':
+    import sys
+    p = sys.argv[1] if len(sys.argv) > 1 else '.'
+    out = write_resource_labels(p)
+    sz = os.path.getsize(out)
+    print(f'wrote {out} ({sz} bytes)')