Fix current benchmark reconstruction

Support the public benchmark namespace and select concrete migrated physics
presets so reconstructed current commits execute the requested backend.

Author: Horde

tools/perf_bisection/src/isaaclab_bisection/launch_config.py

@@ -56,14 +56,16 @@ def workload_contract(config: dict[str, Any]) -> dict[str, Any]:
 
 def hydra_args_for_task(task: TaskConfig) -> list[str]:
     """Return Hydra args used by the current local/CI benchmark launch path."""
-    presets: list[str] = []
-    if task.physics_backend == "newton":
-        presets.append("newton_mjwarp")
+    args: list[str] = []
+    if task.physics_backend == "physx":
+        args.append("physics=isaacsim_physx")
+    elif task.physics_backend == "newton":
+        args.append("physics=newton_mjwarp")
     if task.render_backend:
-        presets.append(task.render_backend)
+        args.append(f"renderer={task.render_backend}")
         if task.render_backend == "newton_renderer":
-            presets.append("rgb")
-    return [f"presets={','.join(presets)}"] if presets else []
+            args.append("presets=rgb")
+    return args
 
 
 def task_to_launch_config(

tools/perf_bisection/tests/test_bisect_runner.py

@@ -851,7 +851,24 @@ def test_default_hydra_args_used_when_none_given(self) -> None:
         args = argparse.Namespace(hydra_arg=[])
         resolved = runner._resolve_hydra_args(args, task)
         assert isinstance(resolved, list)
-        assert any("newton" in item for item in resolved)
+        assert resolved == ["physics=newton_mjwarp"]
+
+    def test_physx_backend_selects_isaac_sim_physx(self) -> None:
+        task = runner._build_task(
+            argparse.Namespace(
+                task_id="Isaac-Cartpole-Direct",
+                backend_key="physx",
+                tasks_json=None,
+                num_envs=None,
+                num_frames=None,
+                warmup_frames=None,
+                seed=None,
+                camera_resolution=None,
+                timeout_minutes=None,
+            )
+        )
+
+        assert runner._resolve_hydra_args(argparse.Namespace(hydra_arg=[]), task) == ["physics=isaacsim_physx"]
 
 
 class TestEngineForwardsTaskSpec:

tools/perf_bisection/tests/test_tooling.py

@@ -7,12 +7,13 @@
 
 from __future__ import annotations
 
+import importlib.util
 import json
 import shutil
 import subprocess
 import sys
 from pathlib import Path
-from types import SimpleNamespace
+from types import ModuleType, SimpleNamespace
 
 import pytest
 
@@ -38,6 +39,23 @@
 )
 
 
+def _load_tooling_capability_module() -> ModuleType:
+    path = _REPO_ROOT / "tools" / "perf_smoke_test" / "tooling_capability.py"
+    spec = importlib.util.spec_from_file_location("test_tooling_capability", path)
+    assert spec is not None
+    assert spec.loader is not None
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def _fake_module(name: str, attributes: tuple[str, ...] = ()) -> ModuleType:
+    module = ModuleType(name)
+    for attribute in attributes:
+        setattr(module, attribute, object())
+    return module
+
+
 @pytest.fixture
 def committed_tooling_repo(tmp_path: Path) -> tuple[Path, str]:
     """Create a repository whose committed tooling can be archived by SHA."""
@@ -102,6 +120,27 @@ def test_capability_command_uses_pinned_tooling(tmp_path: Path) -> None:
     assert command[-1] == str(tmp_path / "artifacts" / "tooling_capability.json")
 
 
+@pytest.mark.parametrize("benchmark_namespace", ["isaaclab.benchmark", "isaaclab.test.benchmark"])
+def test_tooling_capability_accepts_current_and_legacy_benchmark_namespaces(
+    monkeypatch: pytest.MonkeyPatch, benchmark_namespace: str
+) -> None:
+    benchmark_attributes = ("BaseIsaacLabBenchmark", "BenchmarkMonitor", "builders", "capture", "stepping")
+    modules = {
+        "isaaclab": _fake_module("isaaclab"),
+        "isaaclab.app": _fake_module("isaaclab.app", ("AppLauncher", "launch_simulation")),
+        benchmark_namespace: _fake_module(benchmark_namespace, benchmark_attributes),
+        f"{benchmark_namespace}.schema": _fake_module(f"{benchmark_namespace}.schema", ("StartupTime",)),
+        "isaaclab_tasks": _fake_module("isaaclab_tasks"),
+        "isaaclab_tasks.utils": _fake_module("isaaclab_tasks.utils", ("setup_preset_cli", "resolve_task_config")),
+    }
+    for name, module in modules.items():
+        monkeypatch.setitem(sys.modules, name, module)
+
+    capability = _load_tooling_capability_module()
+
+    assert capability.check_capabilities() == []
+
+
 def test_resolved_plan_pins_task_metric_and_warmups() -> None:
     resolved = resolve_tooling_plan(_inline_plan(), _REPO_ROOT, tooling_ref="WORKTREE")
 

tools/perf_smoke_test/benchmark_result_adapter.py

@@ -6,9 +6,9 @@
 """Adapter: schema-v1 ``RuntimeBundle`` JSON -> perf-gate normalized fields.
 
 ``perf_runtime.py`` emits a
-:class:`~isaaclab.test.benchmark.schema.RuntimeBundle` (Isaac Lab benchmark
+:class:`~isaaclab.benchmark.schema.RuntimeBundle` (Isaac Lab benchmark
 refactor Part 1, PR #6197) serialized by
-:func:`~isaaclab.test.benchmark.serialize.write_bundle_file`.  This module is the
+:func:`~isaaclab.benchmark.serialize.write_bundle_file`.  This module is the
 single point that reads that JSON and projects it into the flat
 ``provenance`` / ``runtime_resources`` / fps / ``benchmark_info`` shapes the gate's
 :mod:`oracle` and :mod:`build_bench_result` consume, replacing the legacy

tools/perf_smoke_test/contracts.py

@@ -5,7 +5,7 @@
 
 """Typed contracts for the perf-gate's own artifacts (schema v1).
 
-The gate's analogue of :mod:`isaaclab.test.benchmark.schema`: the fields the gate
+The gate's analogue of :mod:`isaaclab.benchmark.schema`: the fields the gate
 computes on are typed dataclass attributes, while open pass-through sub-structures
 (``benchmark_info``, ``provenance``, ``launch_config``, the compatibility contracts)
 stay as ``dict`` fields — mirroring ``RuntimeBundle``'s typed fields + ``extra: dict``.

tools/perf_smoke_test/dev/stub_benchmark.py

@@ -6,11 +6,11 @@
 
 """Local-testing stub that fakes a ``perf_runtime.py`` run without a GPU/sim.
 
-Emits a schema-v1 :class:`~isaaclab.test.benchmark.schema.RuntimeBundle`
+Emits a schema-v1 :class:`~isaaclab.benchmark.schema.RuntimeBundle`
 (``benchmark_runtime_{task}_{stamp}.json``) identical in shape to what the real
 driver writes, so ``build_bench_result.py`` -> ``benchmark_result_adapter`` ->
 ``oracle`` can be exercised end-to-end offline. Uses the real
-``isaaclab.test.benchmark`` builders/serialize (pure-Python, no GPU), so it stays
+``isaaclab.benchmark`` builders/serialize (pure-Python, no GPU), so it stays
 in lockstep with the schema; run it with the Isaac Lab Python env.
 """
 
@@ -26,8 +26,8 @@
 
 from backend_identity import split_backend_key  # noqa: E402
 
-from isaaclab.test.benchmark import builders, serialize  # noqa: E402
-from isaaclab.test.benchmark.schema import (  # noqa: E402
+from isaaclab.benchmark import builders, serialize  # noqa: E402
+from isaaclab.benchmark.schema import (  # noqa: E402
     GpuDeviceInfo,
     Hardware,
     MeanStd,

tools/perf_smoke_test/launch_config.py

@@ -55,14 +55,16 @@ def workload_contract(config: dict[str, Any]) -> dict[str, Any]:
 
 def hydra_args_for_task(task: TaskConfig) -> list[str]:
     """Return Hydra args used by the current local/CI benchmark launch path."""
-    presets: list[str] = []
-    if task.physics_backend == "newton":
-        presets.append("newton_mjwarp")
+    args: list[str] = []
+    if task.physics_backend == "physx":
+        args.append("physics=isaacsim_physx")
+    elif task.physics_backend == "newton":
+        args.append("physics=newton_mjwarp")
     if task.render_backend:
-        presets.append(task.render_backend)
+        args.append(f"renderer={task.render_backend}")
         if task.render_backend == "newton_renderer":
-            presets.append("rgb")
-    return [f"presets={','.join(presets)}"] if presets else []
+            args.append("presets=rgb")
+    return args
 
 
 def task_to_launch_config(

tools/perf_smoke_test/perf_runtime.py

@@ -7,11 +7,11 @@
 
 Thin wrapper over the merged Isaac Lab benchmark core (benchmark refactor
 Part 1/5, PR #6197) that produces a schema-v1
-:class:`~isaaclab.test.benchmark.schema.RuntimeBundle`.  It intentionally does
+:class:`~isaaclab.benchmark.schema.RuntimeBundle`.  It intentionally does
 **not** depend on the still-unmerged ``scripts/benchmarks/runtime.py`` (Part 2/5,
 PR #6198); it only imports the stable, merged building blocks
-(:mod:`~isaaclab.test.benchmark.stepping`, :mod:`~isaaclab.test.benchmark.builders`,
-:mod:`~isaaclab.test.benchmark.capture`) so the perf gate can adopt the typed
+(:mod:`~isaaclab.benchmark.stepping`, :mod:`~isaaclab.benchmark.builders`,
+:mod:`~isaaclab.benchmark.capture`) so the perf gate can adopt the typed
 bundle schema before the rest of the refactor lands.
 
 Difference from the upstream runtime script: the perf gate discards a
@@ -85,8 +85,13 @@
 import gymnasium as gym
 
 from isaaclab.app import launch_simulation
-from isaaclab.test.benchmark import BaseIsaacLabBenchmark, BenchmarkMonitor, builders, capture, stepping
-from isaaclab.test.benchmark.schema import StartupTime
+
+try:
+    from isaaclab.benchmark import BaseIsaacLabBenchmark, BenchmarkMonitor, builders, capture, stepping
+    from isaaclab.benchmark.schema import StartupTime
+except ModuleNotFoundError:
+    from isaaclab.test.benchmark import BaseIsaacLabBenchmark, BenchmarkMonitor, builders, capture, stepping
+    from isaaclab.test.benchmark.schema import StartupTime
 
 import isaaclab_tasks  # noqa: F401
 from isaaclab_tasks.utils import resolve_task_config

tools/perf_smoke_test/tooling_capability.py

@@ -13,6 +13,10 @@
 from pathlib import Path
 
 TOOLING_INCOMPATIBLE_EXIT_CODE = 86
+_BENCHMARK_API_ALTERNATIVES = (
+    ("isaaclab.benchmark", "isaaclab.benchmark.schema"),
+    ("isaaclab.test.benchmark", "isaaclab.test.benchmark.schema"),
+)
 
 
 def _parse_args() -> argparse.Namespace:
@@ -21,27 +25,36 @@ def _parse_args() -> argparse.Namespace:
     return parser.parse_args()
 
 
+def _check_module(module_name: str, names: tuple[str, ...]) -> list[str]:
+    """Return missing names or an import failure for one module."""
+    missing: list[str] = []
+    try:
+        module = __import__(module_name, fromlist=list(names))
+    except Exception as exc:  # noqa: BLE001 - the compatibility report records the exact import failure
+        return [f"{module_name}: {type(exc).__name__}: {exc}"]
+    for name in names:
+        if not hasattr(module, name):
+            missing.append(f"{module_name}.{name}")
+    return missing
+
+
 def check_capabilities() -> list[str]:
     """Return missing API descriptions required by ``perf_runtime.py``."""
-    missing: list[str] = []
-    checks = (
-        ("isaaclab.app", ("AppLauncher", "launch_simulation")),
-        (
-            "isaaclab.test.benchmark",
+    missing = _check_module("isaaclab.app", ("AppLauncher", "launch_simulation"))
+    missing.extend(_check_module("isaaclab_tasks.utils", ("setup_preset_cli", "resolve_task_config")))
+
+    benchmark_failures: list[str] = []
+    for benchmark_module, schema_module in _BENCHMARK_API_ALTERNATIVES:
+        alternative_missing = _check_module(
+            benchmark_module,
             ("BaseIsaacLabBenchmark", "BenchmarkMonitor", "builders", "capture", "stepping"),
-        ),
-        ("isaaclab.test.benchmark.schema", ("StartupTime",)),
-        ("isaaclab_tasks.utils", ("setup_preset_cli", "resolve_task_config")),
-    )
-    for module_name, names in checks:
-        try:
-            module = __import__(module_name, fromlist=list(names))
-        except Exception as exc:  # noqa: BLE001 - the compatibility report records the exact import failure
-            missing.append(f"{module_name}: {type(exc).__name__}: {exc}")
-            continue
-        for name in names:
-            if not hasattr(module, name):
-                missing.append(f"{module_name}.{name}")
+        )
+        alternative_missing.extend(_check_module(schema_module, ("StartupTime",)))
+        if not alternative_missing:
+            break
+        benchmark_failures.extend(alternative_missing)
+    else:
+        missing.extend(benchmark_failures)
     return missing