simulation/modules/IsaacLab/scripts/benchmarks/benchmark_view_comparison.py

# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause

"""Benchmark script comparing FrameView backends and PhysX RigidBodyView.

Compares batched transform operation performance across:

- **USD** (baseline): Isaac Lab's FrameView via USD XformCache
- **Fabric**: Isaac Lab's FrameView via Fabric GPU arrays
- **Newton**: Isaac Lab's Newton FrameView via Warp site kernels
- **PhysX**: PhysX RigidBodyView via PhysX tensor API (reference)

Usage:
    # All backends
    ./isaaclab.sh -p scripts/benchmarks/benchmark_view_comparison.py --num_envs 1024 --device cuda:0 --headless

    # Select specific backends
    ./isaaclab.sh -p scripts/benchmarks/benchmark_view_comparison.py --backends usd fabric newton --headless

    # With profiling
    ./isaaclab.sh -p scripts/benchmarks/benchmark_view_comparison.py --num_envs 1024 --profile --headless
"""

from __future__ import annotations

import argparse

from isaaclab.app import AppLauncher

parser = argparse.ArgumentParser(description="Benchmark FrameView backends and PhysX RigidBodyView.")

parser.add_argument("--num_envs", type=int, default=1000, help="Number of environments to simulate.")
parser.add_argument("--num_iterations", type=int, default=50, help="Number of iterations for each test.")
parser.add_argument(
    "--backends",
    nargs="+",
    default=["usd", "fabric", "newton", "physx"],
    choices=["usd", "fabric", "newton", "physx"],
    help="Backends to benchmark. Default: all four.",
)
parser.add_argument(
    "--profile",
    action="store_true",
    help="Enable profiling with cProfile. Results saved as .prof files for snakeviz visualization.",
)
parser.add_argument(
    "--profile_dir",
    type=str,
    default="./profile_results",
    help="Directory to save profile results. Default: ./profile_results",
)

AppLauncher.add_app_launcher_args(parser)
args_cli = parser.parse_args()

app_launcher = AppLauncher(args_cli)
simulation_app = app_launcher.app

"""Rest everything follows."""

import cProfile
import time

import torch
import warp as wp

from pxr import Gf

import isaaclab.sim as sim_utils
from isaaclab.sim.views import FrameView

try:
    from isaaclab_newton.physics import MJWarpSolverCfg, NewtonCfg
    from isaaclab_newton.sim.views import NewtonSiteFrameView

    HAS_NEWTON = True
except ImportError:
    HAS_NEWTON = False


# ------------------------------------------------------------------
# Benchmark functions
# ------------------------------------------------------------------


@torch.no_grad()
def benchmark_usd_or_fabric(view_type: str, num_iterations: int) -> dict[str, float]:
    """Benchmark USD or Fabric FrameView."""
    timing_results = {}

    print("  Setting up scene")
    sim_utils.create_new_stage()
    start_time = time.perf_counter()
    sim_cfg = sim_utils.SimulationCfg(dt=0.01, device=args_cli.device, use_fabric=(view_type == "fabric"))
    sim = sim_utils.SimulationContext(sim_cfg)
    stage = sim_utils.get_current_stage()
    print(f"  SimulationContext: {time.perf_counter() - start_time:.4f}s")

    object_cfg = sim_utils.ConeCfg(
        radius=0.15,
        height=0.5,
        rigid_props=sim_utils.RigidBodyPropertiesCfg(),
        mass_props=sim_utils.MassPropertiesCfg(mass=1.0),
        collision_props=sim_utils.CollisionPropertiesCfg(),
        visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(0.0, 1.0, 0.0)),
    )
    for i in range(args_cli.num_envs):
        sim_utils.create_prim(f"/World/Env_{i}", "Xform", stage=stage, translation=(i * 2.0, 0.0, 0.0))
        object_cfg.func(f"/World/Env_{i}/Object", object_cfg, translation=(0.0, 0.0, 1.0))
        prim = stage.DefinePrim(f"/World/Env_{i}/Object/Sensor", "Xform")
        sim_utils.standardize_xform_ops(prim)
        prim.GetAttribute("xformOp:translate").Set(Gf.Vec3d(0.1, 0.0, 0.05))
        prim.GetAttribute("xformOp:orient").Set(Gf.Quatd(1.0, 0.0, 0.0, 0.0))

    sim.reset()

    pattern = "/World/Env_.*/Object/Sensor"

    start_time = time.perf_counter()
    if view_type == "fabric" and "cuda" not in args_cli.device:
        raise ValueError("Fabric backend requires CUDA.")
    view = FrameView(pattern, device=args_cli.device, validate_xform_ops=False)
    num_prims = view.count
    timing_results["init"] = time.perf_counter() - start_time

    print(f"  FrameView ({view_type.upper()}) managing {num_prims} prims")

    positions, orientations = view.get_world_poses()

    _run_pose_benchmarks(view, num_prims, num_iterations, timing_results, positions, orientations)

    sim.clear_instance()
    return timing_results


@torch.no_grad()
def benchmark_newton(num_iterations: int) -> dict[str, float]:
    """Benchmark Newton FrameView."""
    from isaaclab.assets import RigidObjectCfg
    from isaaclab.scene import InteractiveScene, InteractiveSceneCfg
    from isaaclab.sim import SimulationCfg, build_simulation_context
    from isaaclab.utils.configclass import configclass

    timing_results = {}

    @configclass
    class _SceneCfg(InteractiveSceneCfg):
        cube: RigidObjectCfg = RigidObjectCfg(
            prim_path="{ENV_REGEX_NS}/Cube",
            spawn=sim_utils.CuboidCfg(
                size=(0.2, 0.2, 0.2),
                rigid_props=sim_utils.RigidBodyPropertiesCfg(),
                mass_props=sim_utils.MassPropertiesCfg(mass=1.0),
                collision_props=sim_utils.CollisionPropertiesCfg(),
            ),
            init_state=RigidObjectCfg.InitialStateCfg(pos=(0.0, 0.0, 1.0)),
        )

    print("  Setting up Newton scene")
    newton_cfg = SimulationCfg(physics=NewtonCfg(solver_cfg=MJWarpSolverCfg()), device=args_cli.device)
    start_time = time.perf_counter()
    ctx = build_simulation_context(device=args_cli.device, sim_cfg=newton_cfg, add_ground_plane=True)
    sim = ctx.__enter__()
    sim._app_control_on_stop_handle = None
    InteractiveScene(_SceneCfg(num_envs=args_cli.num_envs, env_spacing=2.0))

    stage = sim_utils.get_current_stage()
    for i in range(args_cli.num_envs):
        prim = stage.DefinePrim(f"/World/envs/env_{i}/Cube/Sensor", "Xform")
        sim_utils.standardize_xform_ops(prim)
        prim.GetAttribute("xformOp:translate").Set(Gf.Vec3d(0.1, 0.0, 0.05))
        prim.GetAttribute("xformOp:orient").Set(Gf.Quatd(1.0, 0.0, 0.0, 0.0))

    sim.reset()
    print(f"  Newton scene setup: {time.perf_counter() - start_time:.4f}s")

    start_time = time.perf_counter()
    view = NewtonSiteFrameView("/World/envs/env_.*/Cube/Sensor", device=args_cli.device)
    num_prims = view.count
    timing_results["init"] = time.perf_counter() - start_time

    print(f"  Newton FrameView managing {num_prims} prims")

    positions, orientations = view.get_world_poses()

    _run_pose_benchmarks(view, num_prims, num_iterations, timing_results, positions, orientations)

    ctx.__exit__(None, None, None)
    return timing_results


@torch.no_grad()
def benchmark_physx(num_iterations: int) -> dict[str, float]:
    """Benchmark PhysX RigidBodyView."""
    timing_results = {}

    print("  Setting up scene")
    sim_utils.create_new_stage()
    start_time = time.perf_counter()
    sim_cfg = sim_utils.SimulationCfg(dt=0.01, device=args_cli.device, use_fabric=False)
    sim = sim_utils.SimulationContext(sim_cfg)
    stage = sim_utils.get_current_stage()
    print(f"  SimulationContext: {time.perf_counter() - start_time:.4f}s")

    object_cfg = sim_utils.ConeCfg(
        radius=0.15,
        height=0.5,
        rigid_props=sim_utils.RigidBodyPropertiesCfg(),
        mass_props=sim_utils.MassPropertiesCfg(mass=1.0),
        collision_props=sim_utils.CollisionPropertiesCfg(),
        visual_material=sim_utils.PreviewSurfaceCfg(diffuse_color=(0.0, 1.0, 0.0)),
    )
    for i in range(args_cli.num_envs):
        sim_utils.create_prim(f"/World/Env_{i}", "Xform", stage=stage, translation=(i * 2.0, 0.0, 0.0))
        object_cfg.func(f"/World/Env_{i}/Object", object_cfg, translation=(0.0, 0.0, 1.0))

    sim.reset()

    pattern = "/World/Env_*/Object"
    start_time = time.perf_counter()
    physics_sim_view = sim.physics_manager.get_physics_sim_view()
    view = physics_sim_view.create_rigid_body_view(pattern)
    num_prims = view.count
    timing_results["init"] = time.perf_counter() - start_time

    print(f"  PhysX RigidBodyView managing {num_prims} prims")

    all_indices = wp.from_torch(torch.arange(num_prims, dtype=torch.int32, device=args_cli.device))

    transforms = view.get_transforms()
    transforms_t = wp.to_torch(transforms) if isinstance(transforms, wp.array) else transforms
    positions_t = transforms_t[:, :3]
    orientations_t = transforms_t[:, 3:7]

    start_time = time.perf_counter()
    for _ in range(num_iterations):
        transforms = view.get_transforms()
    timing_results["get_world_poses"] = (time.perf_counter() - start_time) / num_iterations

    new_positions = positions_t.clone()
    new_positions[:, 2] += 0.5
    expected_positions = new_positions.clone()
    new_transforms = wp.from_torch(torch.cat([new_positions, orientations_t], dim=-1).contiguous())
    start_time = time.perf_counter()
    for _ in range(num_iterations):
        view.set_transforms(new_transforms, indices=all_indices)
    timing_results["set_world_poses"] = (time.perf_counter() - start_time) / num_iterations

    transforms_after = view.get_transforms()
    ta = wp.to_torch(transforms_after) if isinstance(transforms_after, wp.array) else transforms_after
    pos_ok = torch.allclose(ta[:, :3], expected_positions, atol=1e-4, rtol=0)
    quat_ok = torch.allclose(ta[:, 3:7], orientations_t, atol=1e-4, rtol=0)
    if pos_ok and quat_ok:
        print("  Round-trip verification: PASS")
    else:
        pos_diff = (ta[:, :3] - expected_positions).abs().max().item()
        quat_diff = (ta[:, 3:7] - orientations_t).abs().max().item()
        print(f"  Round-trip verification: FAIL (pos max_diff={pos_diff:.6e}, quat max_diff={quat_diff:.6e})")

    sim.clear_instance()
    return timing_results


def _run_pose_benchmarks(
    view,
    num_prims: int,
    num_iterations: int,
    timing_results: dict,
    positions: wp.array,
    orientations: wp.array,
):
    """Shared benchmark loop for get/set world poses on any FrameView."""
    start_time = time.perf_counter()
    for _ in range(num_iterations):
        view.get_world_poses()
    timing_results["get_world_poses"] = (time.perf_counter() - start_time) / num_iterations

    new_positions = wp.clone(positions)
    new_positions_t = wp.to_torch(new_positions)
    new_positions_t[:, 2] += 0.5
    expected_positions = new_positions_t.clone()

    start_time = time.perf_counter()
    for _ in range(num_iterations):
        view.set_world_poses(new_positions, orientations)
    timing_results["set_world_poses"] = (time.perf_counter() - start_time) / num_iterations

    ret_pos, ret_quat = view.get_world_poses()
    ret_pos_t = wp.to_torch(ret_pos)
    ret_quat_t = wp.to_torch(ret_quat)
    ori_t = wp.to_torch(orientations)

    pos_ok = torch.allclose(ret_pos_t, expected_positions, atol=1e-4, rtol=0)
    quat_ok = torch.allclose(ret_quat_t, ori_t, atol=1e-4, rtol=0)
    if pos_ok and quat_ok:
        print("  Round-trip verification: PASS")
    else:
        pos_diff = (ret_pos_t - expected_positions).abs().max().item()
        quat_diff = (ret_quat_t - ori_t).abs().max().item()
        print(f"  Round-trip verification: FAIL (pos max_diff={pos_diff:.6e}, quat max_diff={quat_diff:.6e})")


# ------------------------------------------------------------------
# Reporting
# ------------------------------------------------------------------


def print_results(results_dict: dict[str, dict[str, float]], num_prims: int, num_iterations: int):
    """Print benchmark results in a formatted table."""
    print("\n" + "=" * 120)
    print(f"BENCHMARK RESULTS: {num_prims} prims, {num_iterations} iterations")
    print("=" * 120)

    impl_names = list(results_dict.keys())
    display_names = {n: n.replace("_", " ").title() for n in impl_names}
    col_width = 22

    header = f"{'Operation':<25}"
    for name in impl_names:
        header += f" {display_names[name] + ' (ms)':>{col_width}}"
    print(header)
    print("-" * 120)

    operations = [
        ("Initialization", "init"),
        ("Get World Poses", "get_world_poses"),
        ("Set World Poses", "set_world_poses"),
    ]

    for op_name, op_key in operations:
        row = f"{op_name:<25}"
        for name in impl_names:
            val = results_dict[name].get(op_key, 0) * 1000
            row += f" {val:>{col_width}.4f}"
        print(row)

    print("=" * 120)

    total_row = f"{'Total':<25}"
    for name in impl_names:
        total = sum(results_dict[name].values()) * 1000
        total_row += f" {total:>{col_width}.4f}"
    print(total_row)

    baseline = "usd"
    if baseline in results_dict and len(impl_names) > 1:
        print("\n" + "=" * 120)
        print(f"SPEEDUP vs {display_names[baseline]}")
        print("=" * 120)
        header = f"{'Operation':<25}"
        for name in impl_names:
            if name != baseline:
                header += f" {display_names[name]:>{col_width}}"
        print(header)
        print("-" * 120)

        base = results_dict[baseline]
        for op_name, op_key in operations:
            row = f"{op_name:<25}"
            base_t = base.get(op_key, 0)
            for name in impl_names:
                if name != baseline:
                    impl_t = results_dict[name].get(op_key, 0)
                    if base_t > 0 and impl_t > 0:
                        row += f" {base_t / impl_t:>{col_width}.2f}x"
                    else:
                        row += f" {'N/A':>{col_width}}"
            print(row)
        print("=" * 120)

    print("\nNotes:")
    print("  - Times are averaged over all iterations")
    print("  - Speedup > 1.0 means faster than USD baseline")
    print("  - PhysX RigidBodyView requires rigid body physics; FrameView works with any Xformable prim")
    print()


# ------------------------------------------------------------------
# Main
# ------------------------------------------------------------------


def main():
    print("=" * 120)
    print("FrameView Benchmark: USD vs Fabric vs Newton vs PhysX")
    print("=" * 120)
    print(f"  Environments: {args_cli.num_envs}")
    print(f"  Iterations:   {args_cli.num_iterations}")
    print(f"  Device:       {args_cli.device}")
    print(f"  Backends:     {', '.join(args_cli.backends)}")
    print()

    if args_cli.profile:
        import os

        os.makedirs(args_cli.profile_dir, exist_ok=True)

    all_timing = {}
    profile_files = {}

    dispatch = {
        "usd": ("usd", "FrameView (USD)", lambda n: benchmark_usd_or_fabric("usd", n)),
        "fabric": ("fabric", "FrameView (Fabric)", lambda n: benchmark_usd_or_fabric("fabric", n)),
        "newton": ("newton", "FrameView (Newton)", lambda n: benchmark_newton(n)),
        "physx": ("physx", "PhysX RigidBodyView", lambda n: benchmark_physx(n)),
    }

    for backend in args_cli.backends:
        if backend == "newton" and not HAS_NEWTON:
            print(f"Skipping {backend}: isaaclab_newton not installed")
            continue

        key, display_name, bench_fn = dispatch[backend]
        print(f"Benchmarking {display_name}...")

        if args_cli.profile:
            profiler = cProfile.Profile()
            profiler.enable()

        timing = bench_fn(args_cli.num_iterations)

        if args_cli.profile:
            profiler.disable()
            pf = f"{args_cli.profile_dir}/{key}_benchmark.prof"
            profiler.dump_stats(pf)
            profile_files[key] = pf
            print(f"  Profile saved to: {pf}")

        all_timing[key] = timing
        print("  Done!\n")

    print_results(all_timing, args_cli.num_envs, args_cli.num_iterations)

    if args_cli.profile:
        print("\n" + "=" * 100)
        print("PROFILING RESULTS")
        print("=" * 100)
        for key, pf in profile_files.items():
            print(f"  snakeviz {pf}")
        print()

    sim_utils.SimulationContext.clear_instance()


if __name__ == "__main__":
    main()