"""E15: guard cost, render throughput, and VRAM at scale. A trained real scene is replicated with spatial offsets to reach tens of millions of primitives, which is the regime that actually saturates memory bandwidth on a contemporary accelerator. At each size we measure the VRAM footprint, the single-frame render time and pixel throughput, and the cost of the support guard, so that the per-frame guard cost is reported as a function of model size rather than at a single small operating point. We also confirm that the guard still removes the catastrophic tail at scale. """ import argparse import json import os import time import numpy as np import torch import faultlib as F import gsmodel from realscene import load_ply, orbit_cameras def replicate(params, k): """Tile the scene k times on a ground-plane grid; shared appearance, offset means.""" m = params["means"] ext = (m.max(0).values - m.min(0).values) side = int(np.ceil(np.sqrt(k))) offs = [] for i in range(k): gx, gy = i % side, i // side offs.append(torch.tensor([gx * ext[0] * 1.1, 0.0, gy * ext[2] * 1.1], device=m.device)) offs = torch.stack(offs, 0) # [k,3] out = {} out["means"] = (m[None] + offs[:, None, :]).reshape(-1, 3).contiguous() for f in ["scales", "quats", "opacities", "sh0", "shN"]: v = params[f] rep = [k] + [1] * (v.dim() - 1) out[f] = v.repeat(*rep).contiguous() return out def timed(fn, iters, warmup=3): for _ in range(warmup): fn() torch.cuda.synchronize(); t = time.time() for _ in range(iters): fn() torch.cuda.synchronize() return (time.time() - t) / iters def main(): ap = argparse.ArgumentParser() ap.add_argument("--ply", required=True) ap.add_argument("--out", default="/root/seu/results/largescene") ap.add_argument("--W", type=int, default=800) ap.add_argument("--mults", default="1,8,20,35,50") ap.add_argument("--vram_budget_gb", type=float, default=29.0) ap.add_argument("--storm_k", type=int, default=1000) ap.add_argument("--storm_frames", type=int, default=300) args = ap.parse_args() os.makedirs(args.out, exist_ok=True) base, sh, N0 = load_ply(args.ply) W = H = args.W vms, Ks = orbit_cameras(base["means"], 4, W, H) rows = [] for k in [int(x) for x in args.mults.split(",")]: torch.cuda.empty_cache(); torch.cuda.reset_peak_memory_stats() try: params = base if k == 1 else replicate(base, k) N = params["means"].shape[0] bounds = F.compute_bounds(params) # warm + render time t_render = timed(lambda: gsmodel.render(params, vms[:1], Ks[:1], W, H, sh), iters=10) t_guard = timed(lambda: F.apply_guard(params, bounds), iters=10) vram = torch.cuda.max_memory_allocated() / 1e9 mpix = W * H / 1e6 / t_render # confirm guard still neutralizes a scale-sign explosion at this scale stored, work = F.quantize_params(params, "fp32") clean, _ = F.render_views(work, vms[:1], Ks[:1], W, H, sh) rng = np.random.default_rng(0); ng, g = [], [] for _ in range(30): gi = int(rng.integers(0, N)); flat = gi * 3 cv, _ = F.flip_one(stored["scales"], work["scales"], flat, 31, "fp32") img, _ = F.render_views(work, vms[:1], Ks[:1], W, H, sh) gimg, _ = F.render_views(F.apply_guard(work, bounds), vms[:1], Ks[:1], W, H, sh) F.restore_one(work["scales"], flat, cv) ng.append(((img[0] - clean[0]).abs().amax(-1) > 1 / 255).float().mean().item()) g.append(((gimg[0] - clean[0]).abs().amax(-1) > 1 / 255).float().mean().item()) del stored, work, clean # effective bandwidth of the guard: it reads+writes only the 14 guarded # components (means 3, scales 3, quats 4, opacity 1, sh0 3); SH-rest skipped guard_bytes = N * 14 * 4 * 2 # read + write guard_bw = guard_bytes / t_guard / 1e9 # GB/s row = {"k": k, "N": int(N), "vram_gb": float(vram), "render_ms": t_render * 1e3, "guard_ms": t_guard * 1e3, "mpix_s": float(mpix), "guard_frac": float(t_guard / t_render), "guard_bw_gbs": float(guard_bw), "param_bits": int(N * 59 * 32), "scalesign_foot_noguard": float(np.mean(ng) * 100), "scalesign_foot_guard": float(np.mean(g) * 100)} rows.append(row) print(f"k={k:3d} N={N:11,d} ({N*59*32/1e9:.1f}e9 bits) VRAM={vram:5.1f}GB " f"render={t_render*1e3:6.2f}ms {mpix:7.1f}Mpix/s guard={t_guard*1e3:.3f}ms " f"({t_guard/t_render*100:.1f}% render, {guard_bw:.0f}GB/s)", flush=True) del params, bounds if vram > args.vram_budget_gb: print("vram budget reached, stopping", flush=True); break except torch.cuda.OutOfMemoryError: print(f"k={k} OOM, stopping", flush=True); break # ---- real-time fault-storm latency at a memory-safe large scene ---- # the storm needs stored+work copies plus render buffers (~3x params), so cap # the replication at a size that fits rather than the largest swept point. storm = None if rows: kmax = next((r["k"] for r in reversed(rows) if r["N"] <= 18_000_000), rows[0]["k"]) try: torch.cuda.empty_cache(); torch.cuda.reset_peak_memory_stats() params = base if kmax == 1 else replicate(base, kmax) N = params["means"].shape[0] bounds = F.compute_bounds(params) stored, work = F.quantize_params(params, "fp32") comps = {f: work[f].reshape(N, -1).shape[1] for f in ["means", "scales", "quats", "opacities", "sh0", "shN"]} FIELDS = ["means", "scales", "quats", "opacities", "sh0", "shN"] rng = np.random.default_rng(0) # sustained latency under a continuous storm of storm_k upsets per frame, guarded import time lat_ng, lat_g = [], [] for _ in range(args.storm_frames): sites = [] for _ in range(args.storm_k): field = FIELDS[int(rng.integers(0, 6))] flat = int(rng.integers(0, N * comps[field])); bit = int(rng.integers(0, 32)) cv, _ = F.flip_one(stored[field], work[field], flat, bit, "fp32"); sites.append((field, flat, cv)) torch.cuda.synchronize(); t0 = time.time() gsmodel.render(work, vms[:1], Ks[:1], W, H, sh); torch.cuda.synchronize() lat_ng.append((time.time() - t0) * 1e3) torch.cuda.synchronize(); t0 = time.time() gw = F.apply_guard(work, bounds); gsmodel.render(gw, vms[:1], Ks[:1], W, H, sh); torch.cuda.synchronize() lat_g.append((time.time() - t0) * 1e3) for field, flat, cv in sites: F.restore_one(work[field], flat, cv) storm = {"N": int(N), "storm_k": args.storm_k, "frames": args.storm_frames, "lat_noguard_ms_mean": float(np.mean(lat_ng)), "lat_noguard_ms_p99": float(np.percentile(lat_ng, 99)), "lat_guard_ms_mean": float(np.mean(lat_g)), "lat_guard_ms_p99": float(np.percentile(lat_g, 99))} print(f"STORM N={N:,} k={args.storm_k}/frame x{args.storm_frames}: " f"no-guard {storm['lat_noguard_ms_mean']:.2f}ms guard {storm['lat_guard_ms_mean']:.2f}ms", flush=True) except torch.cuda.OutOfMemoryError: print("storm OOM", flush=True) json.dump({"rows": rows, "W": W, "storm": storm}, open(os.path.join(args.out, "largescene.json"), "w"), indent=2) print("LARGESCENE_DONE", flush=True) if __name__ == "__main__": main()