# 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 task config resolution through IsaacLab's Hydra preset layer. This measures the pre-Kit path used by training scripts to load an env cfg, resolve ``PresetCfg`` selections, register the plain Hydra config, run Hydra scalar overrides, and return the resolved env/agent cfg objects. The benchmark prints a local summary table and writes per-case measurements to the standard Isaac Lab benchmark backend. It does not create environments and does not require a GPU. Usage:: ./isaaclab.sh -p scripts/benchmarks/benchmark_hydra_resolve.py ./isaaclab.sh -p scripts/benchmarks/benchmark_hydra_resolve.py --suite broad ./isaaclab.sh -p scripts/benchmarks/benchmark_hydra_resolve.py --iterations 100 ./isaaclab.sh -p scripts/benchmarks/benchmark_hydra_resolve.py \ --case cartpole:Isaac-Cartpole-v0:: \ --case anymal:Isaac-Velocity-Rough-Anymal-C-v0::env.scene.num_envs=256 Case format is ``name:task:agent_entry:arg[,arg...]``. Leave ``agent_entry`` or ``arg`` empty when not needed. """ from __future__ import annotations import argparse import contextlib import io import os import statistics import sys import time import warnings from dataclasses import dataclass import gymnasium from isaaclab.test.benchmark import BaseIsaacLabBenchmark, SingleMeasurement sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), "../..")) with warnings.catch_warnings(): warnings.simplefilter("ignore") import isaaclab_tasks # noqa: F401 from isaaclab_tasks.utils.hydra import resolve_task_config from scripts.benchmarks.utils import get_backend_type @dataclass(frozen=True) class Case: name: str task: str agent_entry: str | None = None args: tuple[str, ...] = () QUICK_CASES = ( Case("cartpole_manager", "Isaac-Cartpole-v0"), Case("cartpole_camera_presets", "Isaac-Cartpole-Camera-Presets-Direct-v0", "rl_games_cfg_entry_point"), Case("anymal_rough", "Isaac-Velocity-Rough-Anymal-C-v0"), Case("franka_lift_cube", "Isaac-Lift-Cube-Franka-v0"), Case( "cartpole_camera_newton_ovrtx", "Isaac-Cartpole-Camera-Presets-Direct-v0", "rl_games_cfg_entry_point", ("presets=newton_mjwarp,ovrtx_renderer",), ), Case("anymal_rough_scalar", "Isaac-Velocity-Rough-Anymal-C-v0", None, ("env.scene.num_envs=256",)), ) BROAD_CASES = ( *QUICK_CASES, Case("cartpole_direct", "Isaac-Cartpole-Direct-v0"), Case("cartpole_rgb_direct", "Isaac-Cartpole-RGB-Camera-Direct-v0"), Case("ant_manager", "Isaac-Ant-v0"), Case("humanoid_manager", "Isaac-Humanoid-v0", "rsl_rl_cfg_entry_point"), Case("franka_reach", "Isaac-Reach-Franka-v0"), Case("franka_lift_cube_agent", "Isaac-Lift-Cube-Franka-v0", "sb3_cfg_entry_point"), Case("kuka_allegro_lift", "Isaac-Dexsuite-Kuka-Allegro-Lift-v0", "rsl_rl_cfg_entry_point"), Case( "kuka_allegro_lift_single_camera", "Isaac-Dexsuite-Kuka-Allegro-Lift-v0", "rsl_rl_cfg_entry_point", ("presets=single_camera,rgb128",), ), Case( "kuka_allegro_lift_duo_camera", "Isaac-Dexsuite-Kuka-Allegro-Lift-v0", "rsl_rl_cfg_entry_point", ("presets=duo_camera,rgb128",), ), Case( "kuka_allegro_lift_scalar", "Isaac-Dexsuite-Kuka-Allegro-Lift-v0", "rsl_rl_cfg_entry_point", ("env.scene.num_envs=256",), ), Case( "cartpole_camera_hydra_force", "Isaac-Cartpole-Camera-Presets-Direct-v0", "rl_games_cfg_entry_point", ("++env.scene.num_envs=256",), ), ) SUITES = {"quick": QUICK_CASES, "broad": BROAD_CASES} def _parse_case(spec: str) -> Case: parts = spec.split(":", 3) if len(parts) != 4: raise argparse.ArgumentTypeError("case must have format name:task:agent_entry:arg[,arg...]") name, task, agent_entry, args = parts if not name or not task: raise argparse.ArgumentTypeError("case name and task must be non-empty") return Case( name=name, task=task, agent_entry=agent_entry or None, args=tuple(arg for arg in args.split(",") if arg), ) def _resolve_once(case: Case, *, verbose: bool = False) -> None: old_argv = sys.argv try: sys.argv = [old_argv[0], *case.args] if verbose: resolve_task_config(case.task, case.agent_entry) else: with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()): resolve_task_config(case.task, case.agent_entry) finally: sys.argv = old_argv def _benchmark_case(case: Case, iterations: int, warmup: int, *, verbose: bool) -> list[float]: for _ in range(warmup): _resolve_once(case, verbose=verbose) times_ms = [] for _ in range(iterations): t0 = time.perf_counter_ns() _resolve_once(case, verbose=verbose) t1 = time.perf_counter_ns() times_ms.append((t1 - t0) / 1_000_000) return times_ms def _print_results(results: dict[Case, list[float]]) -> None: print(f"\n{'Case':<32} {'median ms':>10} {'mean ms':>10} {'stdev ms':>10} {'min ms':>10} {'max ms':>10} argv") print(f"{'-' * 32} {'-' * 10} {'-' * 10} {'-' * 10} {'-' * 10} {'-' * 10} {'-' * 24}") for case, times in results.items(): stdev = statistics.stdev(times) if len(times) > 1 else 0.0 argv = " ".join(case.args) if case.args else "(none)" print( f"{case.name:<32} {statistics.median(times):>10.2f} {statistics.mean(times):>10.2f}" f" {stdev:>10.2f} {min(times):>10.2f} {max(times):>10.2f} {argv}" ) def _log_results(benchmark: BaseIsaacLabBenchmark, results: dict[Case, list[float]]) -> None: for case, times in results.items(): stats = { "Median Resolve Task Config Time": statistics.median(times), "Mean Resolve Task Config Time": statistics.mean(times), "Stdev Resolve Task Config Time": statistics.stdev(times) if len(times) > 1 else 0.0, "Min Resolve Task Config Time": min(times), "Max Resolve Task Config Time": max(times), } for name, value in stats.items(): benchmark.add_measurement( "task_config", measurement=SingleMeasurement(name=f"{case.name} {name}", value=value, unit="ms"), ) benchmark.update_manual_recorders() benchmark._finalize_impl() def main() -> int: parser = argparse.ArgumentParser(description="Benchmark env_cfg + Hydra preset resolution.") parser.add_argument("--iterations", type=int, default=50, help="Timed iterations per case.") parser.add_argument("--warmup", type=int, default=5, help="Warmup iterations per case.") parser.add_argument( "--suite", choices=sorted(SUITES), default="quick", help="Named benchmark suite to run when --case is not provided.", ) parser.add_argument( "--case", action="append", type=_parse_case, default=None, help="Benchmark case in format name:task:agent_entry:arg[,arg...]. May be repeated.", ) parser.add_argument( "--benchmark_backend", type=str, default="summary", choices=[ "json", "osmo", "omniperf", "summary", "LocalLogMetrics", "JSONFileMetrics", "OsmoKPIFile", "OmniPerfKPIFile", ], help="Benchmarking backend options, defaults summary.", ) parser.add_argument("--output_path", type=str, default=".", help="Path to output benchmark results.") parser.add_argument("--verbose", action="store_true", help="Keep per-iteration resolver output.") args = parser.parse_args() cases = tuple(args.case) if args.case else SUITES[args.suite] valid_cases = tuple(case for case in cases if case.task in gymnasium.registry) skipped = [case.task for case in cases if case.task not in gymnasium.registry] if skipped: print(f"[WARN] Skipping unregistered task(s): {skipped}") if not valid_cases: print("[ERROR] No valid benchmark cases.") return 1 print("Benchmarking resolve_task_config()") print(f"Iterations: {args.iterations}, warmup: {args.warmup}") results = {case: _benchmark_case(case, args.iterations, args.warmup, verbose=args.verbose) for case in valid_cases} _print_results(results) benchmark = BaseIsaacLabBenchmark( benchmark_name="benchmark_hydra_resolve", backend_type=get_backend_type(args.benchmark_backend), output_path=args.output_path, use_recorders=True, output_prefix="benchmark_hydra_resolve", workflow_metadata={ "metadata": [ {"name": "suite", "data": args.suite if not args.case else "custom"}, {"name": "iterations", "data": args.iterations}, {"name": "warmup", "data": args.warmup}, ] }, ) _log_results(benchmark, results) return 0 if __name__ == "__main__": raise SystemExit(main())