Forward the configured determinism mode to Warp instead of assuming run-to-run

NewtonCfg.deterministic_mode maps to the same warp.DeterministicMode enum the
global uses, so a backend asking for gpu_to_gpu was getting the stronger
guarantee on its solver kernels and a weaker run_to_run everywhere else.

The config strings are the enum members lowercased, so the mode is resolved by
name rather than by duplicating Newton's mapping table.

Author: hujc7

source/isaaclab_rl/isaaclab_rl/entrypoints/common.py

@@ -497,11 +497,11 @@ def apply_env_overrides(args_cli: argparse.Namespace, env_cfg: Any, *, apply_dev
         physics_cfg = getattr(getattr(env_cfg, "sim", None), "physics", None)
         if physics_cfg is not None:
             physics_cfg.deterministic = True
-        request_warp_determinism()
+        request_warp_determinism(physics_cfg)
 
 
-def request_warp_determinism() -> None:
-    """Ask Warp for run-to-run deterministic atomics process-wide.
+def request_warp_determinism(physics_cfg: Any) -> None:
+    """Ask Warp for deterministic atomics process-wide, matching the configured guarantee.
 
     Newton's solvers take a ``deterministic`` argument and apply it as a per-module option, so a
     solver-level request already covers the physics kernels. Its sensor and geometry modules take
@@ -512,14 +512,25 @@ def request_warp_determinism() -> None:
     then break ties differently and a tiled camera renders a handful of pixels differently from
     identical simulation state, which is enough to make an image-observation policy diverge.
 
-    Warp reads this at module build time, so it must be set before the first kernel launch;
-    :func:`apply_env_overrides` runs before the environment is created. An explicit setting is
-    left alone so a caller can still opt into ``GPU_TO_GPU``.
+    A backend that names a stronger guarantee gets it here too: the strings accepted by
+    :attr:`~isaaclab_newton.physics.NewtonCfg.deterministic_mode` are the
+    ``warp.DeterministicMode`` members lowercased, so ``"gpu_to_gpu"`` selects
+    ``GPU_TO_GPU`` rather than being weakened to ``RUN_TO_RUN``. Warp reads the setting at module
+    build time, so it must land before the first kernel launch; :func:`apply_env_overrides` runs
+    before the environment is created. A mode already set on ``warp.config`` is left alone.
+
+    Args:
+        physics_cfg: Resolved physics config, or ``None`` when the config tree carries none.
     """
     import warp as wp
 
-    if wp.config.deterministic == wp.DeterministicMode.NOT_GUARANTEED:
-        wp.config.deterministic = wp.DeterministicMode.RUN_TO_RUN
+    if wp.config.deterministic != wp.DeterministicMode.NOT_GUARANTEED:
+        return
+    requested = getattr(physics_cfg, "deterministic_mode", None)
+    mode = getattr(wp.DeterministicMode, requested.upper(), None) if isinstance(requested, str) else None
+    if mode is None or mode == wp.DeterministicMode.NOT_GUARANTEED:
+        mode = wp.DeterministicMode.RUN_TO_RUN
+    wp.config.deterministic = mode
 
 
 def validate_distributed_device(args_cli: argparse.Namespace) -> None:

source/isaaclab_rl/test/test_entrypoints_common.py

@@ -434,6 +434,34 @@ def test_apply_env_overrides_requests_warp_determinism(monkeypatch: pytest.Monke
     assert wp.config.deterministic == wp.DeterministicMode.RUN_TO_RUN
 
 
+def test_apply_env_overrides_forwards_a_stronger_configured_mode(monkeypatch: pytest.MonkeyPatch) -> None:
+    """A backend asking for ``gpu_to_gpu`` gets it globally, not a weakened ``run_to_run``."""
+    import warp as wp
+
+    monkeypatch.setattr(wp.config, "deterministic", wp.DeterministicMode.NOT_GUARANTEED)
+    physics = _fake_physics_cfg("NewtonCfg", deterministic_mode="gpu_to_gpu")
+    env_cfg = SimpleNamespace(sim=SimpleNamespace(physics=physics))
+
+    args_cli = argparse.Namespace(num_envs=None, device=None, deterministic=True)
+    _rl_common.apply_env_overrides(args_cli, env_cfg, apply_device=False)
+
+    assert wp.config.deterministic == wp.DeterministicMode.GPU_TO_GPU
+
+
+def test_apply_env_overrides_upgrades_an_unset_backend_mode(monkeypatch: pytest.MonkeyPatch) -> None:
+    """``not_guaranteed`` is the shipped default, so it means "unset", not "opt out"."""
+    import warp as wp
+
+    monkeypatch.setattr(wp.config, "deterministic", wp.DeterministicMode.NOT_GUARANTEED)
+    physics = _fake_physics_cfg("NewtonCfg", deterministic_mode="not_guaranteed")
+    env_cfg = SimpleNamespace(sim=SimpleNamespace(physics=physics))
+
+    args_cli = argparse.Namespace(num_envs=None, device=None, deterministic=True)
+    _rl_common.apply_env_overrides(args_cli, env_cfg, apply_device=False)
+
+    assert wp.config.deterministic == wp.DeterministicMode.RUN_TO_RUN
+
+
 def test_apply_env_overrides_keeps_an_explicit_warp_mode(monkeypatch: pytest.MonkeyPatch) -> None:
     """A caller that already chose a stronger guarantee keeps it."""
     import warp as wp