bobframes 0.1.0__py3-none-any.whl

bobframes/reports/instancing_opportunities.py

@@ -0,0 +1,276 @@
+"""Top mesh_hashes by repeat_count + sister 'material batching' section.
+
+Reads _reports/_cache/draws_summary_per_drop.parquet when present; falls back
+to live scan of **/draws.parquet.
+"""
+
+from __future__ import annotations
+
+import os
+import statistics
+import sys
+from collections import Counter, defaultdict
+
+import pyarrow.parquet as papq
+
+from . import base
+
+
+_DRAWS_COLS = [
+    'area', 'drop_date', 'drop_label', 'capture',
+    'mesh_hash', 'program_id', 'vs_shader_id', 'fs_shader_id',
+    'parent_pass_path_norm', 'draw_class', 'num_indices', 'num_instances',
+]
+
+
+def _iter_draws(root: str, drops: list):
+    """Yield row dicts from cache, else live-scan each drop."""
+    cache = base.cache_path(root, 'draws_summary')
+    if os.path.exists(cache):
+        try:
+            t = papq.read_table(cache)
+            cols = {c: t.column(c).to_pylist() for c in t.column_names}
+            wanted_keys = {(d.date, d.label) for d in drops}
+            for i in range(t.num_rows):
+                if (cols['drop_date'][i], cols['drop_label'][i]) not in wanted_keys:
+                    continue
+                yield {c: cols[c][i] for c in cols}
+            return
+        except Exception:
+            pass
+    for d in drops:
+        for r in d.rows:
+            p = os.path.join(r.drop_dir, 'draws.parquet')
+            if not os.path.exists(p):
+                continue
+            try:
+                t = papq.read_table(p, columns=_DRAWS_COLS)
+            except Exception:
+                continue
+            cols = {c: t.column(c).to_pylist() for c in t.column_names}
+            for i in range(t.num_rows):
+                row = {c: cols[c][i] for c in cols}
+                row['drop_date'] = r.drop_date
+                row['drop_label'] = r.drop_label
+                yield row
+
+
+def _drop_dir_for(drops: list, drop_date, drop_label, area) -> str:
+    for d in drops:
+        if d.date == drop_date and d.label == drop_label:
+            for r in d.rows:
+                if r.area == area:
+                    return r.drop_dir
+    return ''
+
+
+def build(root: str, *, drops: list | None = None, ab=None) -> str:
+    if drops is None:
+        drops = base.discover_drops(root)
+    out_path = base.output_path(root, 'instancing_opportunities', ab)
+    out_dir = os.path.dirname(out_path)
+
+    drop_keys = [d.key for d in drops]
+
+    per_mesh: dict = defaultdict(lambda: {
+        'repeat_by_drop': Counter(),
+        'pass_paths': Counter(),
+        'draw_classes': Counter(),
+        'program_ids': Counter(),
+        'num_indices': [],
+        'captures': set(),
+        'areas': set(),
+        'rep_row': None,
+        'rep_drop': None,
+    })
+
+    batching_groups: Counter = Counter()
+    batching_meshes: dict = defaultdict(set)
+    batching_drops: dict = defaultdict(set)
+
+    for row in _iter_draws(root, drops):
+        mh = row.get('mesh_hash')
+        n_idx = row.get('num_indices') or 0
+        prog = row.get('program_id') or 0
+        if not mh or n_idx <= 0 or prog == 0:
+            continue
+        drop_key = f"{row['drop_date']}_{row['drop_label']}"
+        m = per_mesh[mh]
+        m['repeat_by_drop'][drop_key] += 1
+        pass_norm = row.get('parent_pass_path_norm') or ''
+        cls = row.get('draw_class') or 'other'
+        m['pass_paths'][pass_norm] += 1
+        m['draw_classes'][cls] += 1
+        m['program_ids'][prog] += 1
+        m['num_indices'].append(n_idx)
+        m['captures'].add((row['area'], row['drop_date'], row.get('capture')))
+        m['areas'].add(row['area'])
+        if m['rep_row'] is None:
+            m['rep_row'] = row
+            m['rep_drop'] = (row['drop_date'], row['drop_label'])
+
+        inst = row.get('num_instances') or 1
+        if cls in ('opaque', 'prepass') and inst <= 1:
+            fs = row.get('fs_shader_id') or 0
+            key = (pass_norm, fs, cls)
+            batching_groups[key] += 1
+            batching_meshes[key].add(mh)
+            batching_drops[key].add(drop_key)
+
+    ranked = sorted(
+        per_mesh.items(),
+        key=lambda kv: max(kv[1]['repeat_by_drop'].values()) if kv[1]['repeat_by_drop'] else 0,
+        reverse=True,
+    )[:50]
+
+    top_repeat = (max((max(m['repeat_by_drop'].values()) for _, m in ranked
+                        if m['repeat_by_drop']), default=0)
+                  if ranked else 0)
+    n_unique_meshes = len(per_mesh)
+    max_wasted = 0
+    for mh, m in ranked:
+        n_idx_list = m['num_indices']
+        if not n_idx_list:
+            continue
+        n_typ = sorted(n_idx_list)[len(n_idx_list) // 2]
+        max_r = max(m['repeat_by_drop'].values())
+        max_wasted = max(max_wasted, (max_r - 1) * n_typ)
+    pct_deduped = (1.0 - (n_unique_meshes / sum(sum(m['repeat_by_drop'].values())
+                                                  for _, m in per_mesh.items())
+                          if per_mesh else 0)) * 100.0 if per_mesh else 0.0
+
+    parts = [base.page_open('instancing opportunities', hdr_offset_px=120)]
+    parts.append(base.header(
+        'instancing opportunities',
+        drops=len(drops),
+        captures=sum(d.n_captures for d in drops),
+        build_ts=base.now_iso(),
+        crumb_depth=base.crumb_depth(ab),
+    ))
+    parts.append(base.ab_strip(ab))
+    parts.append(base.ab_picker_for(root, 'instancing_opportunities', ab=ab))
+
+    # Summary bar: top 3 meshes by repeat
+    top3 = []
+    for rank_i, (mh, m) in enumerate(ranked[:3], 1):
+        try:
+            n_typ = int(statistics.median(m['num_indices'])) if m['num_indices'] else 0
+        except statistics.StatisticsError:
+            n_typ = 0
+        max_repeat = max(m['repeat_by_drop'].values()) if m['repeat_by_drop'] else 0
+        dominant_pass = m['pass_paths'].most_common(1)[0][0] if m['pass_paths'] else ''
+        dominant_cls = m['draw_classes'].most_common(1)[0][0] if m['draw_classes'] else ''
+        suffix = base.pass_suffix(dominant_pass) or '?'
+        hash_tag = str(mh)[-4:] if mh else ''
+        label = f'{dominant_cls}/{suffix}/{n_typ}v#{hash_tag}'
+        top3.append((label, max_repeat))
+    if top3:
+        headline = f'{top3[0][0]} (repeat {base.fmt_int(top3[0][1])})'
+        sub_bits = [f'{lbl} x{rep}' for lbl, rep in top3[1:]]
+        parts.append(base.summary_bar(
+            'top batch candidates',
+            headline,
+            sub='next: ' + ', '.join(sub_bits) if sub_bits else None,
+            link_href='#top_meshes',
+            link_text='table',
+            tone='neutral',
+        ))
+
+    sec1 = []
+    single = len(drop_keys) == 1
+    sec1.append('<h2 id="top_meshes">top meshes by repeat</h2>')
+    sec1.append('<div class="table-wrap"><rdc-sortable-table>')
+    sec1.append('<table class="report"><thead><tr>')
+    sec1.append('<th>mesh</th>')
+    for i, k in enumerate(drop_keys):
+        head = 'repeat' if single else f'repeat@{base.h(k)}'
+        sec1.append(f'<th class="num">{head}</th>')
+        if i > 0:
+            latest = ' delta-latest' if i == len(drop_keys) - 1 else ''
+            sec1.append(f'<th class="num{latest}">delta</th>')
+    if len(drop_keys) >= 3:
+        sec1.append('<th class="num">trend</th>')
+    sec1.extend([
+        '<th>areas</th>',
+        '<th>dominant pass</th>',
+        '<th class="num">indices typical</th>',
+        '<th class="num">wasted indices</th>',
+        '</tr></thead><tbody>',
+    ])
+
+    for rank_i, (mh, m) in enumerate(ranked, 1):
+        max_repeat = max(m['repeat_by_drop'].values()) if m['repeat_by_drop'] else 0
+        try:
+            n_typ = int(statistics.median(m['num_indices'])) if m['num_indices'] else 0
+        except statistics.StatisticsError:
+            n_typ = 0
+        wasted = (max_repeat - 1) * n_typ
+        rep_row = m['rep_row'] or {}
+        rep_drop_dir = _drop_dir_for(drops, rep_row.get('drop_date'),
+                                      rep_row.get('drop_label'), rep_row.get('area'))
+        dominant_pass = m['pass_paths'].most_common(1)[0][0] if m['pass_paths'] else ''
+        dominant_cls = m['draw_classes'].most_common(1)[0][0] if m['draw_classes'] else ''
+        suffix = base.pass_suffix(dominant_pass) or '?'
+        hash_tag = str(mh)[-4:] if mh else ''
+        mesh_label = f'{dominant_cls}/{suffix}/{n_typ}v#{hash_tag}'
+
+        sec1.append('<tr>')
+        link = base.rel_path_to_drop_index(out_dir, rep_drop_dir, 'draws') if rep_drop_dir else '#'
+        rp = base.rank_pill(rank_i) if rank_i <= 3 else ''
+        sec1.append(
+            f'<td>{rp}<a href="{base.h(link)}" data-link-kind="drill">{base.h(mesh_label)}</a></td>'
+        )
+        prev = None
+        series = []
+        for i, k in enumerate(drop_keys):
+            v = m['repeat_by_drop'].get(k, 0)
+            series.append(v)
+            sec1.append(f'<td class="num">{base.fmt_int(v)}</td>')
+            if i > 0:
+                sec1.append(base.delta_cell(v, prev,
+                    lower_is_better=True, fmt='{:+,.0f}',
+                    regression_threshold_pct=20.0))
+            prev = v
+        if len(drop_keys) >= 3:
+            sec1.append(f'<td class="num">{base.sparkline_svg(series)}</td>')
+
+        areas_str = ', '.join(sorted(m['areas']))
+        sec1.append(f'<td>{base.h(areas_str)}</td>')
+        sec1.append(f'<td>{base.h(base.pass_short(dominant_pass))}</td>')
+        sec1.append(f'<td class="num">{base.fmt_int(n_typ)}</td>')
+        bar = base.inline_bar(wasted, max_wasted) if max_wasted > 0 else ''
+        sec1.append(f'<td class="num">{base.fmt_int(wasted)}{bar}</td>')
+        sec1.append('</tr>')
+    sec1.append('</tbody></table></rdc-sortable-table></div>')
+    parts.append(''.join(sec1))
+
+    sec2 = []
+    sec2.append('<h2 id="batching">potential material batching</h2>')
+    sec2.append('<div class="table-wrap"><rdc-sortable-table>')
+    sec2.append('<table class="report"><thead><tr>')
+    sec2.append('<th>pass</th>')
+    sec2.append('<th>class</th>')
+    sec2.append('<th class="num">repeat</th>')
+    sec2.append('<th class="num">distinct meshes</th>')
+    sec2.append('<th>drops</th>')
+    sec2.append('</tr></thead><tbody>')
+    top_batch = [(k, v) for k, v in batching_groups.items() if v >= 4]
+    top_batch.sort(key=lambda kv: kv[1], reverse=True)
+    for (pass_norm, fs, cls), n in top_batch[:30]:
+        sec2.append('<tr>')
+        sec2.append(f'<td>{base.h(base.pass_short(pass_norm))}</td>')
+        sec2.append(f'<td>{base.h(cls)}</td>')
+        sec2.append(f'<td class="num">{base.fmt_int(n)}</td>')
+        sec2.append(f'<td class="num">{base.fmt_int(len(batching_meshes[(pass_norm, fs, cls)]))}</td>')
+        sec2.append(f'<td>{base.h(", ".join(sorted(batching_drops[(pass_norm, fs, cls)])))}</td>')
+        sec2.append('</tr>')
+    sec2.append('</tbody></table></rdc-sortable-table></div>')
+    parts.append(''.join(sec2))
+
+    parts.append(base.page_close())
+
+    return base.write_report(out_path, parts)
+
+
+if __name__ == '__main__':
+    sys.exit(base.run_report(build, module_name='instancing_opportunities'))

bobframes/reports/orchestrator.py

@@ -0,0 +1,59 @@
+"""Coordinate cache build + per-report build + dashboard + root-index render."""
+
+from __future__ import annotations
+
+import time
+
+from .. import lint
+from ..html import template
+from . import (
+    _dashboard as report_dashboard,
+    base as reports_base,
+    draws_by_class as report_draws_by_class,
+    instancing_opportunities as report_instancing,
+    overdraw as report_overdraw,
+    pass_gpu as report_pass_gpu,
+    shader_hotlist as report_shader,
+    trend_table as report_trend,
+)
+
+_REPORT_MODULES = (
+    report_draws_by_class,
+    report_trend,
+    report_instancing,
+    report_pass_gpu,
+    report_shader,
+    report_overdraw,
+)
+
+
+def render_all_reports(root: str, log) -> int:
+    """Build cache, all 6 reports, dashboard, root index. Returns 0 on success."""
+    t0 = time.monotonic()
+    cache_out = reports_base.build_per_drop_cache(root)
+    log(f'  built per-drop cache: {cache_out} ({time.monotonic()-t0:.1f}s)')
+
+    for mod in _REPORT_MODULES:
+        try:
+            rep = mod.build(root)
+            log(f'  built report: {rep}')
+        except Exception as e:
+            log(f'  {mod.__name__} FAILED: {e}')
+            return 1
+
+    try:
+        dash = report_dashboard.build(root)
+        log(f'  built dashboard: {dash}')
+    except Exception as e:
+        log(f'  dashboard FAILED: {e}')
+        return 1
+
+    log('rendering root index')
+    root_idx = template.render_root(root)
+    root_hits = lint.lint_file(root_idx)
+    if root_hits:
+        for lineno, label, snip in root_hits:
+            log(f'  LINT FAIL {root_idx}:{lineno}: [{label}] {snip}')
+        return 1
+    log(f'  -> {root_idx}')
+    return 0

bobframes/reports/overdraw.py

@@ -0,0 +1,293 @@
+"""Per-RT pixel_history aggregation. Color bar of rejection causes.
+
+Aggregation key: (area, rt_label). Falls back to (area, rt_id) when label empty.
+Gracefully renders 'no data' when pixel_history absent for a drop.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from collections import defaultdict
+
+import pyarrow.parquet as papq
+
+from . import base
+
+
+_PH_COLS = ['area', 'drop_date', 'drop_label', 'capture', 'rt_id',
+            'passed', 'backface_culled', 'depth_test_failed',
+            'stencil_test_failed', 'scissor_clipped', 'shader_discarded']
+
+_RT_COLS = ['area', 'drop_date', 'drop_label', 'capture',
+            'rt_id', 'format', 'width', 'height', 'label',
+            'is_swap_chain_target']
+
+
+def _read_rts(drop: base.DropSet) -> dict:
+    """{(area, capture, rt_id): {label, format, width, height, is_swap}}"""
+    out: dict = {}
+    for r in drop.rows:
+        p = os.path.join(r.drop_dir, 'render_targets.parquet')
+        if not os.path.exists(p):
+            continue
+        try:
+            schema_cols = set(papq.read_schema(p).names)
+            want = [c for c in _RT_COLS if c in schema_cols]
+            t = papq.read_table(p, columns=want)
+        except Exception:
+            continue
+        cols = {c: t.column(c).to_pylist() for c in t.column_names}
+        for i in range(t.num_rows):
+            key = (cols.get('area', [''])[i] if 'area' in cols else r.area,
+                   cols['capture'][i],
+                   cols['rt_id'][i])
+            out[key] = {
+                'label': cols.get('label', [''])[i] if 'label' in cols else '',
+                'format': cols.get('format', [''])[i] if 'format' in cols else '',
+                'width': cols.get('width', [0])[i] if 'width' in cols else 0,
+                'height': cols.get('height', [0])[i] if 'height' in cols else 0,
+                'is_swap': cols.get('is_swap_chain_target', [False])[i] if 'is_swap_chain_target' in cols else False,
+            }
+    return out
+
+
+def _agg_pixel_history(drop: base.DropSet, rt_meta: dict) -> dict:
+    """{(area, group_key): {n_samples, n_passed, n_depth_failed, ...,
+                            'format', 'width', 'height', 'is_swap'}}."""
+    out: dict = defaultdict(lambda: {
+        'n_samples': 0, 'n_passed': 0, 'n_depth_failed': 0,
+        'n_discarded': 0, 'n_scissor': 0, 'n_backface': 0, 'n_stencil': 0,
+        'format': '', 'width': 0, 'height': 0, 'is_swap': False,
+        'rt_id': 0,
+    })
+    any_data = False
+    for r in drop.rows:
+        p = os.path.join(r.drop_dir, 'pixel_history.parquet')
+        if not os.path.exists(p):
+            continue
+        try:
+            schema_cols = set(papq.read_schema(p).names)
+            want = [c for c in _PH_COLS if c in schema_cols]
+            t = papq.read_table(p, columns=want)
+        except Exception:
+            continue
+        if t.num_rows == 0:
+            continue
+        any_data = True
+        cols = {c: t.column(c).to_pylist() for c in t.column_names}
+        for i in range(t.num_rows):
+            cap = cols.get('capture', [''])[i] if 'capture' in cols else ''
+            rt_id = cols.get('rt_id', [0])[i] if 'rt_id' in cols else 0
+            meta = rt_meta.get((r.area, cap, rt_id), {})
+            label = meta.get('label') or f'rt_{rt_id}'
+            key = (r.area, label)
+            bucket = out[key]
+            bucket['n_samples'] += 1
+            bucket['rt_id'] = rt_id
+            if cols.get('passed', [False])[i]:
+                bucket['n_passed'] += 1
+            if cols.get('depth_test_failed', [False])[i]:
+                bucket['n_depth_failed'] += 1
+            if cols.get('shader_discarded', [False])[i]:
+                bucket['n_discarded'] += 1
+            if cols.get('scissor_clipped', [False])[i]:
+                bucket['n_scissor'] += 1
+            if cols.get('backface_culled', [False])[i]:
+                bucket['n_backface'] += 1
+            if cols.get('stencil_test_failed', [False])[i]:
+                bucket['n_stencil'] += 1
+            if not bucket['format'] and meta:
+                bucket['format'] = meta.get('format', '')
+                bucket['width'] = meta.get('width', 0)
+                bucket['height'] = meta.get('height', 0)
+                bucket['is_swap'] = meta.get('is_swap', False)
+    return dict(out) if any_data else {}
+
+
+def _rejection_bar(b: dict) -> str:
+    n = b['n_samples']
+    if n <= 0:
+        return ''
+    weights = {
+        'opaque':       b['n_passed'],
+        'prepass':      b['n_depth_failed'],
+        'ui':           b['n_discarded'],
+        'other':        b['n_scissor'],
+        'shadow':       b['n_backface'],
+        'translucent':  b['n_stencil'],
+    }
+    accounted = sum(weights.values())
+    remainder = n - accounted
+    if remainder > 0:
+        weights['additive'] = remainder
+    return base.class_segments_bar(weights, n)
+
+
+def build(root: str, *, drops: list | None = None, ab=None) -> str:
+    if drops is None:
+        drops = base.discover_drops(root)
+    out_path = base.output_path(root, 'overdraw', ab)
+
+    drop_keys = [d.key for d in drops]
+    per_drop_data: dict = {}
+    for d in drops:
+        meta = _read_rts(d)
+        per_drop_data[d.key] = _agg_pixel_history(d, meta)
+
+    all_keys: set = set()
+    for agg in per_drop_data.values():
+        all_keys.update(agg.keys())
+
+    by_area: dict = defaultdict(list)
+    for area, label in all_keys:
+        by_area[area].append(label)
+
+    parts = [base.page_open('overdraw', hdr_offset_px=120)]
+    parts.append(base.header(
+        'overdraw',
+        drops=len(drops),
+        captures=sum(d.n_captures for d in drops),
+        build_ts=base.now_iso(),
+        crumb_depth=base.crumb_depth(ab),
+    ))
+    parts.append(base.ab_strip(ab))
+    parts.append(base.ab_picker_for(root, 'overdraw', ab=ab))
+
+    # Summary bar: worst shadow RT rejection % (or worst RT rejection if no shadow)
+    worst_rt = None
+    worst_pct = -1.0
+    for area_key, label in all_keys:
+        # Pick the rep bucket (first seen across drops)
+        rep = None
+        for k in drop_keys:
+            b = per_drop_data.get(k, {}).get((area_key, label))
+            if b is not None:
+                rep = b
+                break
+        if not rep:
+            continue
+        ns = rep.get('n_samples', 0)
+        if ns <= 0:
+            continue
+        passed = rep.get('n_passed', 0)
+        reject_pct = 100.0 * (1.0 - passed / ns)
+        label_str = str(label or '').lower()
+        is_shadow = 'shadow' in label_str
+        # Prefer shadow RTs; fall back to highest reject overall
+        score = reject_pct + (10000.0 if is_shadow else 0.0)
+        if score > worst_pct:
+            worst_pct = score
+            worst_rt = (area_key, label or '?', reject_pct, is_shadow)
+    if worst_rt is not None:
+        area_w, label_w, pct_w, is_shadow_w = worst_rt
+        kind = 'shadow rejection' if is_shadow_w else 'rt rejection'
+        tone = 'alarm' if pct_w >= 70 else ('warn' if pct_w >= 40 else 'neutral')
+        parts.append(base.summary_bar(
+            f'worst {kind}',
+            f'{area_w} / {label_w}',
+            sub=f'{base.fmt_float(pct_w, 1)}% rejected',
+            link_href=f'#{base.h(area_w)}',
+            link_text='area',
+            tone=tone,
+        ))
+
+    parts.append('<div class="legend">')
+    for cls, name in [('opaque', 'passed'), ('prepass', 'depth failed'),
+                       ('ui', 'discarded'), ('other', 'scissor'),
+                       ('shadow', 'backface'), ('translucent', 'stencil'),
+                       ('additive', 'other')]:
+        parts.append(f'<span class="chip"><span class="swatch" '
+                     f'style="background: {base.class_color_var(cls)}"></span>{base.h(name)}</span>')
+    parts.append('</div>')
+
+    drops_without_data = [k for k in drop_keys if not per_drop_data.get(k)]
+    if drops_without_data:
+        msg = ', '.join(base.h(k) for k in drops_without_data)
+        parts.append(f'<p class="note">no pixel_history rows in drops: {msg}</p>')
+
+    if not by_area:
+        parts.append('<p class="note">no pixel_history data across all drops</p>')
+    else:
+        for area in sorted(by_area.keys()):
+            rows = []
+            for label in set(by_area[area]):
+                rep = None
+                for k in drop_keys:
+                    b = per_drop_data.get(k, {}).get((area, label))
+                    if b is not None:
+                        rep = b
+                        break
+                max_samples = max((per_drop_data.get(k, {}).get((area, label), {}).get('n_samples', 0)
+                                    for k in drop_keys), default=0)
+                rows.append((label, rep, max_samples))
+            rows.sort(key=lambda x: x[2], reverse=True)
+
+            sec = []
+            sec.append('<table class="report"><thead><tr>')
+            sec.append('<th>rt label</th>')
+            sec.append('<th>format</th>')
+            sec.append('<th>dims</th>')
+            sec.append('<th class="num">samples (latest)</th>')
+            sec.append('<th class="num">passed</th>')
+            sec.append('<th class="num">depth failed</th>')
+            sec.append('<th class="num">discarded</th>')
+            sec.append('<th class="num">scissor</th>')
+            sec.append('<th class="num">backface</th>')
+            sec.append('<th>rejection bar</th>')
+            for i, k in enumerate(drop_keys):
+                sec.append(f'<th class="num">samples@{base.h(k)}</th>')
+                if i > 0:
+                    latest_cls = ' delta-latest' if i == len(drop_keys) - 1 else ''
+                    sec.append(f'<th class="num{latest_cls}">delta</th>')
+            sec.append('</tr></thead><tbody>')
+
+            for label, rep, _ in rows:
+                latest_bucket = None
+                for k in reversed(drop_keys):
+                    b = per_drop_data.get(k, {}).get((area, label))
+                    if b is not None:
+                        latest_bucket = b
+                        break
+                if latest_bucket is None:
+                    continue
+                n = latest_bucket['n_samples']
+                pct = lambda v, total=n: (v / total * 100.0) if total > 0 else 0.0
+                swap = ' (swap)' if latest_bucket.get('is_swap') else ''
+                dims = f'{latest_bucket["width"]}x{latest_bucket["height"]}' if latest_bucket['width'] else ''
+
+                sec.append('<tr>')
+                sec.append(f'<td>{base.h(label)}{base.h(swap)}</td>')
+                sec.append(f'<td>{base.h(latest_bucket.get("format") or "")}</td>')
+                sec.append(f'<td class="num">{base.h(dims)}</td>')
+                sec.append(f'<td class="num">{base.fmt_int(n)}</td>')
+                sec.append(f'<td class="num">{base.fmt_pct(pct(latest_bucket["n_passed"]))}</td>')
+                sec.append(f'<td class="num">{base.fmt_pct(pct(latest_bucket["n_depth_failed"]))}</td>')
+                sec.append(f'<td class="num">{base.fmt_pct(pct(latest_bucket["n_discarded"]))}</td>')
+                sec.append(f'<td class="num">{base.fmt_pct(pct(latest_bucket["n_scissor"]))}</td>')
+                sec.append(f'<td class="num">{base.fmt_pct(pct(latest_bucket["n_backface"]))}</td>')
+                sec.append(f'<td>{_rejection_bar(latest_bucket)}</td>')
+
+                prev_n = None
+                for i, k in enumerate(drop_keys):
+                    bb = per_drop_data.get(k, {}).get((area, label))
+                    cur = bb['n_samples'] if bb else None
+                    sec.append(f'<td class="num">{base.fmt_int(cur) if cur is not None else ""}</td>')
+                    if i > 0:
+                        sec.append(base.delta_cell(
+                            cur if cur is not None else 0,
+                            prev_n,
+                            lower_is_better=None, fmt='{:+,.0f}'))
+                    prev_n = cur
+                sec.append('</tr>')
+            sec.append('</tbody></table>')
+            parts.append(f'<h2 id="{base.h(area)}">{base.h(area)}</h2>')
+            parts.append(f'<div class="table-wrap"><rdc-sortable-table>{"".join(sec)}</rdc-sortable-table></div>')
+
+    parts.append(base.page_close())
+
+    return base.write_report(out_path, parts)
+
+
+if __name__ == '__main__':
+    sys.exit(base.run_report(build, module_name='overdraw'))