scripts/benchmark_evaluate2_timing.py

#!/usr/bin/env python3
"""Legacy timing harness (evaluate2 removed). Use scripts/evaluate.py directly.

This script is deprecated and may be removed. Run evaluate.py with --policy-gpu / --render-gpu.
"""

from __future__ import annotations

import argparse
import json
import os
import subprocess
import sys
from pathlib import Path

OPENPI_ROOT = Path(__file__).resolve().parents[1]
EVAL_SCRIPT = OPENPI_ROOT / "scripts" / "evaluate.py"


def _parse_args() -> argparse.Namespace:
    p = argparse.ArgumentParser(description="Benchmark evaluate2 end-to-end timing")
    p.add_argument("--python", default=sys.executable)
    p.add_argument("--suite", default="libero_10_task")
    p.add_argument("--task-index", type=int, default=4)
    p.add_argument("--rollouts-per-task", type=int, default=1)
    p.add_argument("--max-control-steps", type=int, default=120)
    p.add_argument("--config-name", default="pi05_libero_stage2p5_joint")
    p.add_argument(
        "--checkpoint-dir",
        default="/scratch1/home/zhicao/openpi/checkpoints/pi05_libero_stage2p5_joint/pi05_final/29999",
    )
    p.add_argument("--out-dir", default=str(OPENPI_ROOT / "results" / "timing_benchmark"))
    p.add_argument("--run-name", default="timing_probe")
    p.add_argument(
        "--compare-modes",
        action="store_true",
        help="Run full / light / no-video / no-original presets and print table",
    )
    p.add_argument("--extra-args", nargs=argparse.REMAINDER, help="Passed through to evaluate2")
    return p.parse_args()


def _run_evaluate2(
    *,
    python: str,
    label: str,
    suite: str,
    task_index: int,
    rollouts: int,
    max_steps: int,
    config_name: str,
    checkpoint: str,
    out_dir: str,
    run_name: str,
    mode_flags: list[str],
    extra: list[str] | None,
) -> dict:
    run_slug = f"{run_name}_{label}"
    cmd = [
        python,
        str(EVAL_SCRIPT),
        "--profile-timing",
        "--suites",
        suite,
        "--task-index",
        str(task_index),
        "--rollouts-per-task",
        str(rollouts),
        "--max-control-steps",
        str(max_steps),
        "--config-name",
        config_name,
        "--checkpoint-dir",
        checkpoint,
        "--out-dir",
        out_dir,
        "--run-name",
        run_slug,
        *mode_flags,
    ]
    if extra:
        cmd.extend(extra)

    print(f"\n>>> [{label}] {' '.join(cmd)}", flush=True)
    proc = subprocess.run(cmd, cwd=str(OPENPI_ROOT), env=os.environ.copy(), check=False)
    if proc.returncode != 0:
        raise RuntimeError(f"evaluate2 failed for mode={label} (exit {proc.returncode})")

    timing_path = Path(out_dir) / f"{run_slug}_timing_profile.json"
    if not timing_path.exists():
        raise FileNotFoundError(f"Missing timing JSON: {timing_path}")
    data = json.loads(timing_path.read_text(encoding="utf-8"))
    row = data.get(suite, data)
    row["label"] = label
    row["timing_json"] = str(timing_path)
    return row


def _extrapolate_hours(row: dict) -> float:
    s_per = float(row.get("s_per_rollout", 0))
    n_tasks = int(row.get("task_ids", 1))
    rollouts = int(row.get("rollouts_per_task", 1))
    max_steps = int(row.get("max_control_steps", 0))
    measured = int(row.get("control_steps", 0))
    policy_load = float(row.get("policy_load_s", 0))
    total_rollouts = n_tasks * rollouts
    if max_steps <= 0 or measured <= 0:
        return (s_per * total_rollouts + policy_load) / 3600.0
    scale = float(max_steps) / float(measured)
    return (s_per * scale * total_rollouts + policy_load) / 3600.0


def _print_row(row: dict) -> None:
    label = row.get("label", "?")
    print(f"\n--- {label} ---")
    phases = [
        ("policy_load", "policy_load_s"),
        ("env_build", "env_build_s"),
        ("rollout_reset", "rollout_reset_s"),
        ("wait_env_step", "wait_env_step_s"),
        ("prepare_raw", "prepare_raw_s"),
        ("policy_infer", "policy_infer_s"),
        ("render_overlay", "render_overlay_s"),
        ("render_original", "render_original_s"),
        ("control_env_step", "control_env_step_s"),
        ("video_overlay_encode", "video_overlay_encode_s"),
        ("video_original_encode", "video_original_encode_s"),
        ("hdf5_write", "hdf5_write_s"),
    ]
    total = float(row.get("rollout_wall_s", 0))
    for name, key in phases:
        v = float(row.get(key, 0))
        if v <= 0:
            continue
        pct = 100.0 * v / total if total > 0 else 0
        print(f"  {name:22} {v:8.2f}s  ({pct:5.1f}% of rollout wall)")
    print(f"  {'TOTAL rollout':22} {total:8.2f}s  ({row.get('rollouts', '?')} rollouts)")
    if "ms_per_control_step" in row:
        print(f"  ms/control_step:       {row['ms_per_control_step']}")
    if "s_per_policy_infer" in row:
        print(f"  s/policy_infer:        {row['s_per_policy_infer']}")
    est_h = _extrapolate_hours(row)
    n_tasks = row.get("task_ids", "?")
    rpt = row.get("rollouts_per_task", "?")
    print(
        f"  Extrapolate suite:     {n_tasks} tasks × {rpt} rollouts "
        f"≈ {est_h:.2f} h  (light_eval={row.get('light_eval')}, "
        f"orig_video={row.get('save_original_rollout_video')})"
    )
    print(f"  JSON: {row.get('timing_json', '')}")


def _print_compare_table(rows: list[dict]) -> None:
    print("\n" + "=" * 88)
    print("MODE COMPARISON (one task, limited max_control_steps)")
    print("=" * 88)
    headers = ["label", "s/rollout", "ms/step", "s/infer", "est_suite_h", "light", "orig_vid"]
    print(" | ".join(f"{h:>12}" for h in headers))
    print("-" * 88)
    for r in rows:
        print(
            " | ".join(
                f"{str(r.get(h, '')):>12}"
                for h in [
                    "label",
                    "s_per_rollout",
                    "ms_per_control_step",
                    "s_per_policy_infer",
                    f"{_extrapolate_hours(r):.2f}",
                    "light_eval",
                    "save_original_rollout_video",
                ]
            )
        )
    print("=" * 88)
    if len(rows) >= 2:
        base = float(rows[0].get("s_per_rollout", 0))
        fast = min(float(r.get("s_per_rollout", 0)) for r in rows[1:])
        if base > 0 and fast > 0:
            print(f"Fastest vs baseline rollout: {base / fast:.2f}x speedup")


def main() -> None:
    args = _parse_args()
    extra = list(args.extra_args or [])

    presets: list[tuple[str, list[str]]]
    if args.compare_modes:
        presets = [
            ("full_default", []),
            ("no_original_video", ["--no-save-original-rollout-video"]),
            ("light_eval", ["--light-eval"]),
        ]
    else:
        presets = [("probe", [])]

    rows: list[dict] = []
    for label, flags in presets:
        rows.append(
            _run_evaluate2(
                python=args.python,
                label=label,
                suite=args.suite,
                task_index=args.task_index,
                rollouts=args.rollouts_per_task,
                max_steps=args.max_control_steps,
                config_name=args.config_name,
                checkpoint=args.checkpoint_dir,
                out_dir=args.out_dir,
                run_name=args.run_name,
                mode_flags=flags,
                extra=extra,
            )
        )
        _print_row(rows[-1])

    if len(rows) > 1:
        _print_compare_table(rows)


if __name__ == "__main__":
    main()