"""Run the capture on an isolated Modal GPU and retrieve every dumped tensor.""" import argparse import concurrent.futures import fcntl import hashlib import io import json from pathlib import Path import shutil import tarfile import threading import time from types import SimpleNamespace import modal ROOT = Path(__file__).resolve().parents[1] MODELS = { "image": ("Qwen/Qwen-Image-2.1-Turbo", "fc13ba1986fcb905854dc8de2f52eee395f49b5b", "qwen-image21"), "qwen-next": ("nvidia/Qwen3.8-Flash-Next-NVFP4", "fc694b54fb0174e0913e6adf86691ef85a4ead47", "qwen-next-nvfp4"), "deepseek41": ("deepseek-ai/DeepSeek-V4.1-Flash", "5254448103b6254fc646dacbca1cbbf20e9216c1", "deepseek41"), "ltx25": ("pinecoresystems/LTX-2.5-serving", "93deb76408feee57d04b3cfeed3ded56a7a068ee", "ltx-2.5-sglang"), } def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--name", required=True) parser.add_argument("--kind", choices=list(MODELS), default="image") parser.add_argument("--volume", default="inference-kernels-capture-20261014") parser.add_argument("--image", default="im-vgNLOxfbAM8S5H1zofJQON") parser.add_argument("--model-path") parser.add_argument("--reference-image", help="Conditioning image path on the worker volume.") parser.add_argument("--audio-sdpa-backend", choices=("default", "math"), default="default") parser.add_argument("--video-sdpa-backend", choices=("default", "math"), default="default") parser.add_argument("--num-outputs", type=int, choices=[1, 2, 4], default=1, help="Images or videos generated per request; independent of retrieval filters.") parser.add_argument("--lock-directory", type=Path, required=True) parser.add_argument("--case", action="append") parser.add_argument("--max-output-tokens", type=int) parser.add_argument("--retrieve-only", action="store_true") parser.add_argument("--prepare-model", action="store_true", help="Download the pinned full checkpoint on a CPU worker, then exit.") parser.add_argument("--batch-sizes", type=lambda value: {int(item) for item in value.split(',')}, help="Retrieve representative batch sizes; retain the complete raw capture on the volume.") parser.add_argument("--context-endpoints", action="store_true", help="For QSA contexts above 65536 tokens, retrieve the first and last captured decode step.") args = parser.parse_args() repo_id, revision, folder = MODELS[args.kind] args.model_path = args.model_path or "/task/data/models/" + folder output = ROOT / "results" / "capture" / args.name if args.retrieve_only: receipt = json.loads((output / "run.json").read_text()) return retrieve(output, receipt, modal.Volume.from_name(receipt["volume"]), args.batch_sizes, args.context_endpoints) output.mkdir(parents=True, exist_ok=False) remote_relative = "captures/" + args.name remote = "/task/data/" + remote_relative app = modal.App.lookup("inference-kernels-capture-20261014", create_if_missing=True) volume = modal.Volume.from_name(args.volume, create_if_missing=True) image = modal.Image.from_id(args.image) environment = {name: "/task/data/cache/" + folder for name, folder in ( ("HF_HOME", "hf"), ("XDG_CACHE_HOME", "xdg"), ("TRITON_CACHE_DIR", "triton"), ("TORCH_EXTENSIONS_DIR", "torch"), ("CUDA_CACHE_PATH", "cuda"), ("FLASHINFER_WORKSPACE_BASE", "flashinfer"), ("TVM_FFI_CACHE_DIR", "tvm"), ("DG_JIT_CACHE_DIR", "deepgemm"), ("DJ_JIT_CACHE_DIR", "deepjit"), ("TILELANG_CACHE_DIR", "tilelang"), )} environment.update(PYTHONDONTWRITEBYTECODE="1", PYTHONUNBUFFERED="1", OMP_NUM_THREADS="8", MAX_JOBS="8") receipt = dict(started_at=time.time(), image_id=args.image, volume=args.volume, remote_dataset=remote_relative) def save(): (output / "run.json").write_text(json.dumps(receipt, indent=2) + "\n") if args.prepare_model: sandbox = modal.Sandbox.create(app=app, image=image, cpu=8, memory=32768, timeout=14400, volumes={"/task/data": volume}, env=environment) receipt.update(sandbox_id=sandbox.object_id, model=repo_id, revision=revision, model_path=args.model_path) save() try: source = ("from huggingface_hub import snapshot_download; " f"print(snapshot_download({repo_id!r}, revision={revision!r}, local_dir={args.model_path!r}, max_workers=8))") command = ["python", "-u", "-c", source] if args.kind == "ltx25": command = ["python", "-u", "-c", (ROOT / "scripts/prepare_ltx.py").read_text(), "--source", "/task/data/models/ltx-2.5-original", "--output", args.model_path] process = sandbox.exec(*command, timeout=13800) with (output / "download.log").open("w") as log: for line in process.stdout: print(line, end="", flush=True) log.write(line) log.write(process.stderr.read()) process.wait() receipt["returncode"] = process.returncode finally: sandbox.terminate() receipt["finished_at"] = time.time() save() raise SystemExit(receipt.get("returncode", 1)) with modal.enable_output(): sandbox = modal.Sandbox.create(app=app, image=image, gpu="B200:4" if args.kind == "deepseek41" else "B200", cpu=16, memory=524288 if args.kind == "deepseek41" else 262144, timeout=14400, volumes={"/task/data": volume}, env=environment) receipt["sandbox_id"] = sandbox.object_id save() print("SANDBOX", sandbox.object_id, flush=True) locks = [] try: process = sandbox.exec("nvidia-smi", "--query-gpu=uuid,name,memory.used", "--format=csv,noheader") receipt["gpu"] = process.stdout.read().strip() process.wait() if process.returncode: raise RuntimeError("GPU inventory failed") args.lock_directory.mkdir(parents=True, exist_ok=True) for gpu in receipt["gpu"].splitlines(): if int(gpu.rsplit(",", 1)[1].strip().split()[0]) > 64: raise RuntimeError("The allocated GPU already has substantial memory in use") lock = (args.lock_directory / ("modal-" + gpu.split(",")[0] + ".lock")).open("a+") fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB) locks.append(lock) archive = io.BytesIO() receipt["source_sha256"] = {} with tarfile.open(fileobj=archive, mode="w:gz") as bundle: for path in [ROOT / "scripts/capture_inputs.py", ROOT / "scripts/sitecustomize.py", ROOT / "scripts/capture_llm.py", ROOT / "scripts/agentx_shapes.json", ROOT / "scripts/capture_ltx.py", *sorted((ROOT / "definitions").rglob("*.json"))]: bundle.add(path, arcname=str(path.relative_to(ROOT))) receipt["source_sha256"][str(path.relative_to(ROOT))] = hashlib.sha256(path.read_bytes()).hexdigest() process = sandbox.exec("mkdir", "-p", "/task/repo") process.wait() process = sandbox.exec("tar", "xzf", "-", "-C", "/task/repo", text=False) process.stdin.write(archive.getvalue()) process.stdin.write_eof() process.stdin.drain() process.wait() if process.returncode: raise RuntimeError("Capture source upload failed") worker = {"image": "scripts/capture_inputs.py", "ltx25": "scripts/capture_ltx.py"}.get(args.kind, "scripts/capture_llm.py") command = ["python", "-u", worker, "--model-path", args.model_path, "--output-root", remote] if args.kind in ("qwen-next", "deepseek41"): command.extend(("--kind", args.kind)) if args.kind in ("image", "ltx25"): command.extend(("--num-outputs", str(args.num_outputs))) if args.kind == "ltx25": command.extend(("--audio-sdpa-backend", args.audio_sdpa_backend)) command.extend(("--video-sdpa-backend", args.video_sdpa_backend)) if args.reference_image: command.extend(("--reference-image", args.reference_image)) for case in args.case or []: command.extend(("--case", case)) if args.max_output_tokens: command.extend(("--max-output-tokens", str(args.max_output_tokens))) receipt["command"] = command save() process = sandbox.exec(*command, workdir="/task/repo", timeout=13200) with (output / "client.log").open("w") as log: def copy(stream): for line in stream: print(line, end="", flush=True) log.write(line) log.flush() threads = [threading.Thread(target=copy, args=(stream,)) for stream in (process.stdout, process.stderr)] for thread in threads: thread.start() process.wait() for thread in threads: thread.join() receipt["returncode"] = process.returncode if process.returncode == 0: process = sandbox.exec("python", "-u", "scripts/capture_inputs.py", "--replay-root", remote, "--device", "cuda", workdir="/task/repo", timeout=5400) with (output / "replay.log").open("w") as log: for line in process.stdout: print(line, end="", flush=True) log.write(line) log.write(process.stderr.read()) process.wait() receipt["replay_returncode"] = process.returncode receipt["returncode"] = process.returncode finally: inventory_code = ( "import json,hashlib; from pathlib import Path; " f"root=Path({remote!r}); " "print(json.dumps([{'relative':str(p.relative_to(root)), 'size':p.stat().st_size, " "'sha256':hashlib.sha256(p.read_bytes()).hexdigest() if p.suffix in ('.json','.jsonl') else None} " "for p in root.rglob('*') if p.is_file()]))" ) try: if "gpu" in receipt: process = sandbox.exec("python", "-c", inventory_code) inventory_text = process.stdout.read() process.wait() if process.returncode == 0: receipt["files"] = json.loads(inventory_text) finally: try: sandbox.terminate() finally: for lock in locks: fcntl.flock(lock, fcntl.LOCK_UN) lock.close() receipt["finished_at"] = time.time() save() retrieve(output, receipt, volume, args.batch_sizes, args.context_endpoints) raise SystemExit(receipt.get("returncode", 1)) def retrieve(output, receipt, volume, batch_sizes=None, context_endpoints=False): # Shutdown commits the mounted volume. Stream files without a duplicate # multi-gigabyte archive on the local disk. if "files" not in receipt: raise RuntimeError("The worker did not provide a complete file inventory") remote_relative = receipt["remote_dataset"] entries = [SimpleNamespace(path=remote_relative + "/" + item["relative"], size=item["size"], sha256=item["sha256"]) for item in receipt["files"]] dataset = output / "dataset" if batch_sizes or context_endpoints: def read_metadata(relative): item = next(item for item in receipt['files'] if item['relative'] == relative) for attempt in range(15): try: data = b''.join(volume.read_file(remote_relative + '/' + relative)) if len(data) == item['size'] and hashlib.sha256(data).hexdigest() == item['sha256']: return data.decode() except FileNotFoundError: pass time.sleep(2) raise IOError(f'Incomplete metadata: {relative}') rewritten = {} ids = set() blobs = set() source_receipts = [json.loads(line) for line in read_metadata('results/captures.jsonl').splitlines()] eligible = {row['uuid'] for row in source_receipts if not batch_sizes or row['axes'].get('B', 1) in batch_sizes} if context_endpoints: groups = {} for row in source_receipts: if (row['uuid'] in eligible and row['definition'].startswith('qsa_') and max(row.get('scheduler_sequence_lengths', [0])) > 65536): groups.setdefault((row['definition'], row['request_id']), []).append(row) for rows in groups.values(): endpoints = {min(row['step'] for row in rows), max(row['step'] for row in rows)} eligible.difference_update(row['uuid'] for row in rows if row['step'] not in endpoints) def collect(value): if isinstance(value, dict): if value.get('type') == 'safetensors': blobs.add(value['path']) else: for child in value.values(): collect(child) elif isinstance(value, list): for child in value: collect(child) for item in receipt['files']: relative = item['relative'] if relative.startswith('workloads/') and relative.endswith('.jsonl'): selected = [row for line in read_metadata(relative).splitlines() for row in [json.loads(line)] if row['workload']['uuid'] in eligible] ids.update(row['workload']['uuid'] for row in selected) collect(selected) rewritten[relative] = ''.join(json.dumps(row, sort_keys=True) + '\n' for row in selected) selected = [row for row in source_receipts if row['uuid'] in ids] collect(selected) rewritten['results/captures.jsonl'] = ''.join(json.dumps(row, sort_keys=True) + '\n' for row in selected) report = json.loads(read_metadata('results/replay.json')) total = len(report['cases']) report['cases'] = [case for case in report['cases'] if case['uuid'] in ids] receipt['selection'] = dict(batch_sizes=sorted(batch_sizes) if batch_sizes else None, context_endpoints=context_endpoints, source_workloads=total, retrieved_workloads=len(ids), raw_capture_retained=remote_relative) report['selection'] = receipt['selection'] rewritten['results/replay.json'] = json.dumps(report, indent=2) + '\n' for item in receipt['files']: if item['relative'].startswith('blob/') and item['relative'] not in blobs: (dataset / item['relative']).unlink(missing_ok=True) entries = [entry for entry in entries if not entry.path.startswith(remote_relative + '/blob/') or str(Path(entry.path).relative_to(remote_relative)) in blobs] for entry in entries: relative = str(Path(entry.path).relative_to(remote_relative)) if relative in rewritten: data = rewritten[relative].encode() target = dataset / relative target.parent.mkdir(parents=True, exist_ok=True) target.write_bytes(data) entry.size, entry.sha256 = len(data), hashlib.sha256(data).hexdigest() required = sum(entry.size for entry in entries) for entry in entries: relative = Path(entry.path).relative_to(remote_relative) if relative.parts[:2] != ("blob", "workloads"): continue target, existing = dataset / relative, ROOT / relative if not target.exists() and existing.is_file() and existing.stat().st_size == entry.size: target.parent.mkdir(parents=True, exist_ok=True) try: target.hardlink_to(existing) except OSError: pass # A different filesystem can still use normal retrieval. def complete(entry): target = dataset / Path(entry.path).relative_to(remote_relative) return (target.is_file() and target.stat().st_size == entry.size and (entry.sha256 is None or hashlib.sha256(target.read_bytes()).hexdigest() == entry.sha256)) pending = [entry for entry in entries if not complete(entry)] needed = sum(entry.size for entry in pending) if needed + 2 * 1024**3 > shutil.disk_usage(output).free: raise OSError(f"Need {needed} bytes plus 2 GiB reserve to retrieve the complete dataset") def fetch(entry): relative = Path(entry.path).relative_to(remote_relative) target = dataset / relative target.parent.mkdir(parents=True, exist_ok=True) for attempt in range(15): written = 0 digest = hashlib.sha256() try: with target.open("wb") as stream: for chunk in volume.read_file(entry.path): written += stream.write(chunk) digest.update(chunk) except FileNotFoundError: time.sleep(2) continue if written == entry.size and (entry.sha256 is None or digest.hexdigest() == entry.sha256): return time.sleep(2) raise IOError(f"Incomplete retrieval: {entry.path}") with concurrent.futures.ThreadPoolExecutor(max_workers=16) as executor: list(executor.map(fetch, pending)) receipt.update(retrieved_files=len(entries), retrieved_bytes=required) (output / "run.json").write_text(json.dumps(receipt, indent=2) + "\n") print(f"RETRIEVED {len(entries)} files, {required} bytes", flush=True) if __name__ == "__main__": main()