Allocate CPU staging buffers on a CPU sim too

The pinned-host ``self._cpu_*`` buffers are referenced unconditionally by
every CPU-only-binding write helper, but ``_create_buffers`` previously
allocated them only when ``dev != "cpu"``.  On a CPU sim, the very first
write helper (``write_joint_stiffness_to_sim_index`` during
``_process_actuators_cfg``) raised
``AttributeError: 'ArticulationData' object has no attribute
'_cpu_joint_stiffness'`` and aborted ``_initialize_impl``.

Allocate the buffers unconditionally; on a CPU sim they hold a redundant
copy of ``self._<X>.data`` and the staging copy is a cheap intra-CPU
memcpy.  ``pinned`` is still gated on ``dev != "cpu"`` so we don't ask
Warp for page-locked memory when no CUDA transfer is going to use it.

Author: AntoineRichard

source/isaaclab_ovphysx/isaaclab_ovphysx/assets/articulation/articulation_data.py

@@ -320,40 +320,41 @@ def _create_buffers(self) -> None:  # noqa: C901
         self._spatial_tendon_limit = TimestampedBuffer((N, T_spa, 2), dev, wp.float32)
         self._spatial_tendon_rest_length = TimestampedBuffer((N, T_spa), dev, wp.float32)
 
-        # -- Pinned-host CPU staging buffers for CPU-only bindings on a non-CPU sim.
+        # -- CPU staging buffers for CPU-only bindings.
         # Pre-allocate all of them so there is no per-step allocation on the hot path.
         # These are keyed by tensor_type in self._cpu_staging_buffers; _binding_read
         # selects the right one at read time.  The sizes must match the binding shapes
-        # (flat float32).
-        if dev != "cpu":
-            self._cpu_body_mass = wp.zeros((N, L), dtype=wp.float32, device="cpu", pinned=True)
-            self._cpu_body_coms = wp.zeros((N, L, 7), dtype=wp.float32, device="cpu", pinned=True)
-            self._cpu_body_inertia = wp.zeros((N, L, 9), dtype=wp.float32, device="cpu", pinned=True)
-            self._cpu_joint_stiffness = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=True)
-            self._cpu_joint_damping = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=True)
-            self._cpu_joint_position_limit = wp.zeros((N, D, 2), dtype=wp.float32, device="cpu", pinned=True)
-            self._cpu_joint_velocity_limit = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=True)
-            self._cpu_joint_effort_limit = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=True)
-            self._cpu_joint_armature = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=True)
-            self._cpu_joint_friction_static = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=True)
-            self._cpu_joint_friction_dynamic = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=True)
-            self._cpu_joint_friction_viscous = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=True)
-            if T_fix > 0:
-                self._cpu_fixed_tendon_stiffness = wp.zeros((N, T_fix), dtype=wp.float32, device="cpu", pinned=True)
-                self._cpu_fixed_tendon_damping = wp.zeros((N, T_fix), dtype=wp.float32, device="cpu", pinned=True)
-                self._cpu_fixed_tendon_limit_stiffness = wp.zeros(
-                    (N, T_fix), dtype=wp.float32, device="cpu", pinned=True
-                )
-                self._cpu_fixed_tendon_rest_length = wp.zeros((N, T_fix), dtype=wp.float32, device="cpu", pinned=True)
-                self._cpu_fixed_tendon_offset = wp.zeros((N, T_fix), dtype=wp.float32, device="cpu", pinned=True)
-                self._cpu_fixed_tendon_pos_limits = wp.zeros((N, T_fix, 2), dtype=wp.float32, device="cpu", pinned=True)
-            if T_spa > 0:
-                self._cpu_spatial_tendon_stiffness = wp.zeros((N, T_spa), dtype=wp.float32, device="cpu", pinned=True)
-                self._cpu_spatial_tendon_damping = wp.zeros((N, T_spa), dtype=wp.float32, device="cpu", pinned=True)
-                self._cpu_spatial_tendon_limit_stiffness = wp.zeros(
-                    (N, T_spa), dtype=wp.float32, device="cpu", pinned=True
-                )
-                self._cpu_spatial_tendon_offset = wp.zeros((N, T_spa), dtype=wp.float32, device="cpu", pinned=True)
+        # (flat float32).  On a GPU sim the buffers are pinned-host (page-locked) so
+        # the wheel can dispatch async copies; on a CPU sim the staging copy is
+        # functionally redundant but the buffer must still exist for the write
+        # helpers, so we allocate unpinned and pay only the intra-CPU memcpy.
+        pinned = dev != "cpu"
+        self._cpu_body_mass = wp.zeros((N, L), dtype=wp.float32, device="cpu", pinned=pinned)
+        self._cpu_body_coms = wp.zeros((N, L, 7), dtype=wp.float32, device="cpu", pinned=pinned)
+        self._cpu_body_inertia = wp.zeros((N, L, 9), dtype=wp.float32, device="cpu", pinned=pinned)
+        self._cpu_joint_stiffness = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=pinned)
+        self._cpu_joint_damping = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=pinned)
+        self._cpu_joint_position_limit = wp.zeros((N, D, 2), dtype=wp.float32, device="cpu", pinned=pinned)
+        self._cpu_joint_velocity_limit = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=pinned)
+        self._cpu_joint_effort_limit = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=pinned)
+        self._cpu_joint_armature = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=pinned)
+        self._cpu_joint_friction_static = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=pinned)
+        self._cpu_joint_friction_dynamic = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=pinned)
+        self._cpu_joint_friction_viscous = wp.zeros((N, D), dtype=wp.float32, device="cpu", pinned=pinned)
+        if T_fix > 0:
+            self._cpu_fixed_tendon_stiffness = wp.zeros((N, T_fix), dtype=wp.float32, device="cpu", pinned=pinned)
+            self._cpu_fixed_tendon_damping = wp.zeros((N, T_fix), dtype=wp.float32, device="cpu", pinned=pinned)
+            self._cpu_fixed_tendon_limit_stiffness = wp.zeros((N, T_fix), dtype=wp.float32, device="cpu", pinned=pinned)
+            self._cpu_fixed_tendon_rest_length = wp.zeros((N, T_fix), dtype=wp.float32, device="cpu", pinned=pinned)
+            self._cpu_fixed_tendon_offset = wp.zeros((N, T_fix), dtype=wp.float32, device="cpu", pinned=pinned)
+            self._cpu_fixed_tendon_pos_limits = wp.zeros((N, T_fix, 2), dtype=wp.float32, device="cpu", pinned=pinned)
+        if T_spa > 0:
+            self._cpu_spatial_tendon_stiffness = wp.zeros((N, T_spa), dtype=wp.float32, device="cpu", pinned=pinned)
+            self._cpu_spatial_tendon_damping = wp.zeros((N, T_spa), dtype=wp.float32, device="cpu", pinned=pinned)
+            self._cpu_spatial_tendon_limit_stiffness = wp.zeros(
+                (N, T_spa), dtype=wp.float32, device="cpu", pinned=pinned
+            )
+            self._cpu_spatial_tendon_offset = wp.zeros((N, T_spa), dtype=wp.float32, device="cpu", pinned=pinned)
 
         # Read initial joint/body properties from bindings (one-time CPU reads).
         self._read_initial_properties()