perf: scale FabricFrameView selections to the view, not the stage

source/isaaclab/changelog.d/fix-physx-newton-camera-pose-scaling.rst

@@ -0,0 +1,13 @@
+Fixed
+^^^^^
+
+* Fixed :class:`~isaaclab.scene_data.SceneDataProvider` transform mapping stalling
+  at high rigid-body counts, which delayed setup by minutes in scenes with
+  thousands of environments.
+
+Added
+^^^^^
+
+* Added :meth:`~isaaclab.sim.views.BaseFrameView.close` to release backend state
+  authored by a frame view. Backends also release best-effort on garbage
+  collection, but only an explicit close is deterministic.

source/isaaclab/isaaclab/envs/utils/camera_view.py

@@ -250,10 +250,13 @@ def prim_world_positions(
         for env_id in env_indices:
             prim_path = env_path_from_template(prim_path_template, env_id)
             view = FrameView(prim_path, device="cpu", stage=stage)
-            if view.count != 1:
-                raise RuntimeError(f"expected one prim, got {view.count}")
-            pos_w, _ = view.get_world_poses()
-            pos = pos_w.torch[0].detach().cpu()
+            try:
+                if view.count != 1:
+                    raise RuntimeError(f"expected one prim, got {view.count}")
+                pos_w, _ = view.get_world_poses()
+                pos = pos_w.torch[0].detach().cpu()
+            finally:
+                view.close()
             positions.append((float(pos[0]), float(pos[1]), float(pos[2])))
         return torch.tensor(positions, dtype=torch.float32)
     except Exception:

source/isaaclab/isaaclab/scene_data/scene_data_provider.py

@@ -5,7 +5,6 @@
 
 from __future__ import annotations
 
-import contextlib
 import logging
 import re
 from collections import deque
@@ -213,10 +212,13 @@ def create_mapping(self, paths: list[str | None]) -> wp.array(dtype=wp.int32) |
             paths or if no mapping is needed.
         """
         if input_paths := self.backend.transform_paths:
-            mapping = [-1] * len(input_paths)
-            for i, path in enumerate(input_paths):
-                with contextlib.suppress(ValueError):
-                    mapping[i] = paths.index(path)
+            # The map keeps resolution linear in the number of paths. For duplicate
+            # paths the first occurrence wins, matching ``list.index``.
+            path_to_out: dict[str | None, int] = {}
+            for out_idx, out_path in enumerate(paths):
+                if out_path not in path_to_out:
+                    path_to_out[out_path] = out_idx
+            mapping = [path_to_out.get(path, -1) for path in input_paths]
             if not np.array_equal(mapping, np.arange(len(input_paths))):
                 return wp.array(mapping, dtype=wp.int32)
         return None

source/isaaclab/isaaclab/sensors/camera/camera.py

@@ -221,6 +221,12 @@ def __del__(self):
         """Unsubscribes from callbacks and cleans up renderer resources."""
         # unsubscribe callbacks
         super().__del__()
+        # release the frame view's backend state (getattr: _view is assigned in
+        # _initialize_impl, so it is absent if construction failed earlier)
+        view = getattr(self, "_view", None)
+        if view is not None:
+            view.close()
+            self._view = None
         # cleanup render resources (renderer may be None if never initialized)
         if self._renderer is not None:
             self._renderer.cleanup(self._render_data)
@@ -901,5 +907,7 @@ def _invalidate_initialize_callback(self, event):
         self._renderer = None
         # call parent
         super()._invalidate_initialize_callback(event)
-        # set all existing views to None to invalidate them
-        self._view = None
+        # release backend state deterministically, then invalidate the view
+        if self._view is not None:
+            self._view.close()
+            self._view = None

source/isaaclab/isaaclab/sim/views/base_frame_view.py

@@ -62,6 +62,17 @@ def device(self) -> str:
         """Device where arrays are allocated (``"cpu"`` or ``"cuda:0"``)."""
         ...
 
+    def close(self) -> None:
+        """Release backend state authored by this view. The view must not be used afterwards.
+
+        The base implementation is a no-op; backends that author persistent
+        state (e.g. the Fabric backend's per-view index attributes) override it.
+        Backends also release best-effort when the view is garbage collected,
+        but only an explicit :meth:`close` is deterministic -- collection
+        timing is up to the interpreter.  Calling :meth:`close` more than once
+        is safe.
+        """
+
     # ------------------------------------------------------------------
     # Write scope -- recommended API for all transform writes.
     # ------------------------------------------------------------------

source/isaaclab/isaaclab/utils/warp/fabric.py

@@ -21,13 +21,15 @@
     IndexedFabricArrayMat44d = Any
     ArrayUInt32 = Any
     ArrayUInt32_1d = Any
+    ArrayInt32_1d = Any
     ArrayFloat32_2d = Any
 else:
     FabricArrayUInt32 = wp.fabricarray(dtype=wp.uint32)
     FabricArrayMat44d = wp.fabricarray(dtype=wp.mat44d)
     IndexedFabricArrayMat44d = wp.indexedfabricarray(dtype=wp.mat44d)
     ArrayUInt32 = wp.array(ndim=1, dtype=wp.uint32)
     ArrayUInt32_1d = wp.array(dtype=wp.uint32)
+    ArrayInt32_1d = wp.array(dtype=wp.int32)
     ArrayFloat32_2d = wp.array(ndim=2, dtype=wp.float32)
 
 
@@ -46,6 +48,29 @@ def arange_k(a: ArrayUInt32_1d):
     a[tid] = wp.uint32(tid)
 
 
+@wp.kernel(enable_backward=False)
+def map_view_indices_to_fabric_slots(view_indices: FabricArrayUInt32, fabric_slots: ArrayInt32_1d):
+    """Invert a selection's per-prim view-index attribute into a slot lookup table.
+
+    Inverts a permutation: ``view_indices`` holds each selected prim's view-side
+    index, and after the launch ``fabric_slots[view_index]`` is that prim's
+    fabric-side slot, ready to use as :class:`wp.indexedfabricarray` indices.
+
+    The launch dimension must equal the selection's prim count, and the stored
+    view indices must cover ``0..dim-1`` exactly for the table to be complete.
+    """
+    fabric_slot = int(wp.tid())
+    view_index = int(view_indices[fabric_slot])
+    fabric_slots[view_index] = fabric_slot
+
+
+@wp.kernel(enable_backward=False)
+def gather_fabric_slots(slots: ArrayInt32_1d, gather_map: ArrayUInt32_1d, out_slots: ArrayInt32_1d):
+    """Gather ``slots`` entries through ``gather_map``: ``out_slots[i] = slots[gather_map[i]]``."""
+    i = int(wp.tid())
+    out_slots[i] = slots[int(gather_map[i])]
+
+
 @wp.kernel(enable_backward=False)
 def decompose_fabric_transformation_matrix_to_warp_arrays(
     fabric_matrices: FabricArrayMat44d,

source/isaaclab_mimic/changelog.d/fix-fabric-frameview-stall.rst

@@ -0,0 +1,5 @@
+Fixed
+^^^^^
+
+* Fixed :class:`SceneAsset` leaking its cached frame view when the view is rebuilt,
+  which left the view's backend state to be released on garbage collection.

source/isaaclab_mimic/isaaclab_mimic/locomanipulation_sdg/scene_utils.py

@@ -112,6 +112,8 @@ def _get_xform_view(self) -> FrameView:
         cloned prims exist.
         """
         if self._xform_view is None or self._xform_view.count == 0:
+            if self._xform_view is not None:
+                self._xform_view.close()
             entity = self.scene[self.entity_name]
             prim_path = (
                 entity.prim_path

source/isaaclab_physx/changelog.d/fix-physx-newton-camera-pose-scaling.rst

@@ -0,0 +1,14 @@
+Fixed
+^^^^^
+
+* Fixed camera world-pose resolution stalling at high environment counts under the
+  PhysX backend, which caused multi-second pauses between rendered frames and
+  benchmark timeouts.
+
+Added
+^^^^^
+
+* Added :meth:`close` to the PhysX Fabric frame view, removing its per-view Fabric
+  index attributes so that views recreated over the same prims no longer accumulate
+  attributes. Views dropped without closing are cleaned up on garbage collection,
+  with a warning.