v2 locker docker cpu test stable

docker-entrypoint.sh

@@ -7,6 +7,7 @@ fi
 
 export CUDA_VISIBLE_DEVICES=-1
 export NVIDIA_VISIBLE_DEVICES=void
+export ROBOMME_RENDER_BACKEND="${ROBOMME_RENDER_BACKEND:-pci:0}"
 unset NVIDIA_DRIVER_CAPABILITIES
 unset SAPIEN_RENDER_DEVICE
 unset MUJOCO_GL
@@ -18,6 +19,7 @@ echo "[entrypoint] Starting RoboMME Gradio app in CPU-only mode"
 echo "[entrypoint] OMP_NUM_THREADS=$OMP_NUM_THREADS"
 echo "[entrypoint] CUDA_VISIBLE_DEVICES=$CUDA_VISIBLE_DEVICES"
 echo "[entrypoint] NVIDIA_VISIBLE_DEVICES=$NVIDIA_VISIBLE_DEVICES"
+echo "[entrypoint] ROBOMME_RENDER_BACKEND=$ROBOMME_RENDER_BACKEND"
 echo "[entrypoint] SAPIEN_RENDER_DEVICE=${SAPIEN_RENDER_DEVICE:-<unset>}"
 echo "[entrypoint] VK_ICD_FILENAMES=${VK_ICD_FILENAMES:-<unset>}"
 exec "$@"

gradio-web/main.py

@@ -16,9 +16,11 @@ VIDEOS_DIR = APP_DIR / "videos"
 TEMP_DEMOS_DIR = PROJECT_ROOT / "temp_demos"
 CWD_TEMP_DEMOS_DIR = Path.cwd() / "temp_demos"
 DEFAULT_LLVMPipe_ICD = Path("/usr/share/vulkan/icd.d/lvp_icd.x86_64.json")
+DEFAULT_CPU_RENDER_BACKEND = "pci:0"
 CPU_ONLY_ENV_OVERRIDES = {
     "CUDA_VISIBLE_DEVICES": "-1",
     "NVIDIA_VISIBLE_DEVICES": "void",
+    "ROBOMME_RENDER_BACKEND": DEFAULT_CPU_RENDER_BACKEND,
 }
 CPU_ONLY_ENV_CLEAR_KEYS = (
     "NVIDIA_DRIVER_CAPABILITIES",
@@ -115,6 +117,7 @@ def log_runtime_graphics_env():
         "NVIDIA_DRIVER_CAPABILITIES",
         "VK_ICD_FILENAMES",
         "OMP_NUM_THREADS",
+        "ROBOMME_RENDER_BACKEND",
         "SAPIEN_RENDER_DEVICE",
         "MUJOCO_GL",
     ]

gradio-web/minimal_maniskill_cpu_step.py

@@ -7,12 +7,29 @@ execution path stays as small as possible.
 from __future__ import annotations
 
 import argparse
+import os
+import sys
 import warnings
+from pathlib import Path
 
 import gymnasium as gym
 import mani_skill.envs  # noqa: F401 - registers ManiSkill environments
 
 
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+SRC_DIR = PROJECT_ROOT / "src"
+
+if str(PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(PROJECT_ROOT))
+if str(SRC_DIR) not in sys.path:
+    sys.path.insert(0, str(SRC_DIR))
+
+import robomme  # noqa: F401,E402 - applies ManiSkill PCI render-backend patch
+
+
+os.environ.setdefault("ROBOMME_RENDER_BACKEND", "pci:0")
+
+
 warnings.filterwarnings(
     "ignore",
     message=r"CUDA reports that you have .* fork_rng",
@@ -32,7 +49,7 @@ def main() -> None:
         control_mode="pd_joint_pos",
         render_mode="rgb_array",
         sim_backend="physx_cpu",
-        render_backend="sapien_cpu",
+        render_backend=os.environ["ROBOMME_RENDER_BACKEND"],
     )
 
     try:

gradio-web/minimal_robomme_env_cpu_step.py

@@ -26,6 +26,7 @@ if str(SRC_DIR) not in sys.path:
 def configure_cpu_only_runtime() -> None:
     os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
     os.environ["NVIDIA_VISIBLE_DEVICES"] = "void"
+    os.environ.setdefault("ROBOMME_RENDER_BACKEND", "pci:0")
     os.environ.pop("NVIDIA_DRIVER_CAPABILITIES", None)
     os.environ.pop("SAPIEN_RENDER_DEVICE", None)
     os.environ.pop("MUJOCO_GL", None)
@@ -52,6 +53,7 @@ def main() -> None:
     args = parser.parse_args()
 
     import robomme.robomme_env as robomme_env
+    from robomme.env_record_wrapper.episode_config_resolver import resolve_render_backend
 
     env_cls = getattr(robomme_env, args.env_class)
     env = None
@@ -64,7 +66,7 @@ def main() -> None:
             render_mode="rgb_array",
             reward_mode="dense",
             sim_backend="physx_cpu",
-            render_backend="sapien_cpu",
+            render_backend=resolve_render_backend(),
             seed=args.seed,
         )
         print("instantiate ok", flush=True)

gradio-web/test/test_episode_builder_cpu_backend.py

@@ -64,8 +64,56 @@ def test_builder_make_env_for_episode_forces_cpu_backends(monkeypatch, reload_mo
     assert captured["kwargs"]["render_mode"] == "rgb_array"
     assert captured["kwargs"]["reward_mode"] == "dense"
     assert captured["kwargs"]["sim_backend"] == "physx_cpu"
-    assert captured["kwargs"]["render_backend"] == "sapien_cpu"
+    assert captured["kwargs"]["render_backend"] == "pci:0"
     assert captured["kwargs"]["seed"] == 123
     assert captured["kwargs"]["difficulty"] == "hard"
     assert _FakeDemonstrationWrapper.last_kwargs["gui_render"] is False
     assert _FakeFailAwareWrapper.last_env is env.env
+
+
+def test_builder_make_env_for_episode_honors_render_backend_override(monkeypatch, reload_module):
+    resolver = reload_module("robomme.env_record_wrapper.episode_config_resolver")
+    captured = {}
+
+    monkeypatch.setitem(
+        sys.modules,
+        "robomme.env_record_wrapper.DemonstrationWrapper",
+        types.SimpleNamespace(DemonstrationWrapper=_FakeDemonstrationWrapper),
+    )
+    monkeypatch.setitem(
+        sys.modules,
+        "robomme.env_record_wrapper.FailAwareWrapper",
+        types.SimpleNamespace(FailAwareWrapper=_FakeFailAwareWrapper),
+    )
+
+    def fake_make(env_id, **kwargs):
+        captured["env_id"] = env_id
+        captured["kwargs"] = kwargs
+        return _FakeEnv()
+
+    monkeypatch.setattr(resolver.gym, "make", fake_make)
+    monkeypatch.setenv("ROBOMME_RENDER_BACKEND", "pci:42")
+
+    builder = resolver.BenchmarkEnvBuilder(
+        env_id="BinFill",
+        dataset="train",
+        action_space="joint_angle",
+        gui_render=False,
+    )
+    monkeypatch.setattr(builder, "resolve_episode", lambda episode_idx: (None, None))
+
+    builder.make_env_for_episode(1)
+
+    assert captured["kwargs"]["render_backend"] == "pci:42"
+
+
+def test_robomme_patches_maniskill_to_preserve_pci_render_backend(reload_module):
+    robomme = reload_module("robomme")
+    assert robomme is not None
+
+    from mani_skill.envs.utils.system import backend as ms_backend
+
+    backend_name, device_id = ms_backend.parse_backend_device_id("pci:0000:00:00.0")
+
+    assert backend_name == "pci:0000:00:00.0"
+    assert device_id is None

gradio-web/test/test_main_launch_config.py

@@ -7,6 +7,7 @@ from pathlib import Path
 
 
 DEFAULT_LLVMPipe_ICD = "/usr/share/vulkan/icd.d/lvp_icd.x86_64.json"
+DEFAULT_CPU_RENDER_BACKEND = "pci:0"
 
 
 class _FakeDemo:
@@ -54,6 +55,7 @@ def test_main_launch_passes_ui_css_and_forces_cpu_runtime(monkeypatch, reload_mo
     assert fake_demo.launch_kwargs["head"] == fake_demo.head
     assert os.environ["CUDA_VISIBLE_DEVICES"] == "-1"
     assert os.environ["NVIDIA_VISIBLE_DEVICES"] == "void"
+    assert os.environ["ROBOMME_RENDER_BACKEND"] == DEFAULT_CPU_RENDER_BACKEND
     assert os.environ["VK_ICD_FILENAMES"] == "/tmp/another_nvidia_icd.json"
     assert "NVIDIA_DRIVER_CAPABILITIES" not in os.environ
     assert "SAPIEN_RENDER_DEVICE" not in os.environ
@@ -83,6 +85,7 @@ def test_configure_cpu_only_runtime_autosets_llvmpipe_icd(monkeypatch, reload_mo
 
     assert os.environ["CUDA_VISIBLE_DEVICES"] == "-1"
     assert os.environ["NVIDIA_VISIBLE_DEVICES"] == "void"
+    assert os.environ["ROBOMME_RENDER_BACKEND"] == DEFAULT_CPU_RENDER_BACKEND
     assert os.environ["VK_ICD_FILENAMES"] == DEFAULT_LLVMPipe_ICD
     assert "NVIDIA_DRIVER_CAPABILITIES" not in os.environ
     assert "SAPIEN_RENDER_DEVICE" not in os.environ
@@ -92,6 +95,7 @@ def test_configure_cpu_only_runtime_autosets_llvmpipe_icd(monkeypatch, reload_mo
 def test_configure_cpu_only_runtime_preserves_existing_vk_icd(monkeypatch, reload_module):
     monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "4")
     monkeypatch.setenv("NVIDIA_VISIBLE_DEVICES", "all")
+    monkeypatch.setenv("ROBOMME_RENDER_BACKEND", "pci:9")
     monkeypatch.setenv("SAPIEN_RENDER_DEVICE", "cuda")
     monkeypatch.setenv("NVIDIA_DRIVER_CAPABILITIES", "graphics")
     monkeypatch.setenv("VK_ICD_FILENAMES", "/tmp/custom_icd.json")
@@ -100,6 +104,7 @@ def test_configure_cpu_only_runtime_preserves_existing_vk_icd(monkeypatch, reloa
     main = reload_module("main")
     monkeypatch.setenv("CUDA_VISIBLE_DEVICES", "5")
     monkeypatch.setenv("NVIDIA_VISIBLE_DEVICES", "all")
+    monkeypatch.setenv("ROBOMME_RENDER_BACKEND", "pci:7")
     monkeypatch.setenv("SAPIEN_RENDER_DEVICE", "cuda")
     monkeypatch.setenv("NVIDIA_DRIVER_CAPABILITIES", "graphics")
     monkeypatch.setenv("VK_ICD_FILENAMES", "/tmp/preserved_icd.json")
@@ -109,6 +114,7 @@ def test_configure_cpu_only_runtime_preserves_existing_vk_icd(monkeypatch, reloa
 
     assert os.environ["CUDA_VISIBLE_DEVICES"] == "-1"
     assert os.environ["NVIDIA_VISIBLE_DEVICES"] == "void"
+    assert os.environ["ROBOMME_RENDER_BACKEND"] == "pci:0"
     assert os.environ["VK_ICD_FILENAMES"] == "/tmp/preserved_icd.json"
     assert "NVIDIA_DRIVER_CAPABILITIES" not in os.environ
     assert "SAPIEN_RENDER_DEVICE" not in os.environ
@@ -127,4 +133,5 @@ def test_configure_cpu_only_runtime_clears_stale_sapien_render_device(monkeypatc
 
     assert os.environ["CUDA_VISIBLE_DEVICES"] == "-1"
     assert os.environ["NVIDIA_VISIBLE_DEVICES"] == "void"
+    assert os.environ["ROBOMME_RENDER_BACKEND"] == DEFAULT_CPU_RENDER_BACKEND
     assert "SAPIEN_RENDER_DEVICE" not in os.environ

human_readme.md

@@ -155,6 +155,7 @@ A2: This Docker image is configured for CPU-only execution and should not rely o
 ```python
 os.environ['CUDA_VISIBLE_DEVICES'] = '-1'
 os.environ['NVIDIA_VISIBLE_DEVICES'] = 'void'
+os.environ.setdefault('ROBOMME_RENDER_BACKEND', 'pci:0')  # llvmpipe software Vulkan on CPU
 os.environ.pop('SAPIEN_RENDER_DEVICE', None)
 os.environ.pop('NVIDIA_DRIVER_CAPABILITIES', None)
 os.environ.pop('MUJOCO_GL', None)

src/robomme/__init__.py

@@ -0,0 +1,28 @@
+"""RoboMME package initialization."""
+
+from __future__ import annotations
+
+
+def _patch_maniskill_pci_render_backend() -> None:
+    """Allow ManiSkill to pass PCI-style Vulkan device strings through intact."""
+    try:
+        from mani_skill.envs.utils.system import backend as ms_backend
+    except Exception:
+        return
+
+    if getattr(ms_backend, "_robomme_pci_backend_patch", False):
+        return
+
+    original = ms_backend.parse_backend_device_id
+
+    def patched_parse_backend_device_id(backend: str):
+        if isinstance(backend, str) and backend.startswith("pci:"):
+            return backend, None
+        return original(backend)
+
+    ms_backend.parse_backend_device_id = patched_parse_backend_device_id
+    ms_backend._robomme_pci_backend_patch = True
+
+
+_patch_maniskill_pci_render_backend()
+

src/robomme/env_record_wrapper/episode_config_resolver.py

@@ -14,6 +14,7 @@ DATASET_ROOT = Path(__file__).resolve().parents[1] / "env_metadata"
 
 _ALLOWED_DATASETS = {"train", "test"}
 _ALLOWED_ACTION_SPACES = {"joint_angle", "ee_pose", "waypoint", "multi_choice"}
+_DEFAULT_CPU_RENDER_BACKEND = "pci:0"
 _DEFAULT_TASK_LIST = [
     "PickXtimes",
     "StopCube",
@@ -87,6 +88,16 @@ def get_episode_metadata(
     return metadata_index.get((task, episode))
 
 
+def resolve_render_backend(default: str = _DEFAULT_CPU_RENDER_BACKEND) -> str:
+    """Resolve the render backend for CPU-only execution.
+
+    Docker CPU mode uses llvmpipe, which SAPIEN exposes as a Vulkan PCI device
+    rather than the string "cpu".
+    """
+    value = str(os.environ.get("ROBOMME_RENDER_BACKEND", default)).strip()
+    return value or default
+
+
 class BenchmarkEnvBuilder:
     """
     Episode environment builder.
@@ -196,7 +207,7 @@ class BenchmarkEnvBuilder:
             render_mode=self.render_mode,
             reward_mode="dense",
             sim_backend="physx_cpu",
-            render_backend="sapien_cpu",
+            render_backend=resolve_render_backend(),
         )
         if seed is not None:
             env_kwargs["seed"] = seed