perf(ovrtx): deferred tile extraction - extract on write_output not render

Move tile extraction from render() to write_output() via lazy
_ensure_extraction(). render() now only calls _renderer.step() and stores
the frame reference. Extraction happens on first write_output() call.

This separates the render kick from buffer consumption, allowing
future overlap opportunities.

Author: ncournia-nv

source/isaaclab_ov/isaaclab_ov/renderers/ovrtx_renderer.py

@@ -395,7 +395,11 @@ def write_output(
         output_name: str,
         output_data: torch.Tensor,
     ) -> None:
-        """Copy from render_data warp buffer to output tensor."""
+        """Copy from render_data warp buffer to output tensor.
+
+        Triggers deferred tile extraction on first access after render().
+        """
+        self._ensure_extraction(render_data)
         if output_name not in render_data.warp_buffers:
             return
         src = render_data.warp_buffers[output_name]
@@ -515,7 +519,12 @@ def _process_render_frame(self, render_data: OVRTXRenderData, frame, output_buff
                 )
 
     def render(self, render_data: OVRTXRenderData) -> None:
-        """Render the scene into the provided RenderData."""
+        """Render the scene and defer tile extraction until buffers are needed.
+
+        Instead of immediately extracting tiles (which stalls on rendering completion),
+        we store the render products and defer extraction to write_output(). This allows
+        training/physics work to overlap with rendering on the GPU.
+        """
         if not self._initialized_scene:
             raise RuntimeError("Scene not initialized. Call initialize() first.")
         if self._renderer is None or len(self._render_product_paths) == 0:
@@ -527,13 +536,30 @@ def render(self, render_data: OVRTXRenderData) -> None:
             )
             product_path = self._render_product_paths[0]
             if product_path in products and len(products[product_path].frames) > 0:
-                self._process_render_frame(
-                    render_data,
-                    products[product_path].frames[0],
-                    render_data.warp_buffers,
-                )
+                # Store frame for deferred extraction instead of extracting immediately
+                render_data._pending_frame = products[product_path].frames[0]
+                render_data._pending_products = products
+                render_data._extraction_done = False
+            else:
+                render_data._pending_frame = None
+                render_data._pending_products = None
+                render_data._extraction_done = True
         except Exception as e:
             logger.warning("OVRTX rendering failed: %s", e, exc_info=True)
+            render_data._pending_frame = None
+            render_data._pending_products = None
+            render_data._extraction_done = True
+
+    def _ensure_extraction(self, render_data: OVRTXRenderData) -> None:
+        """Extract tiles from the pending frame if not already done."""
+        if getattr(render_data, '_extraction_done', True):
+            return
+        frame = getattr(render_data, '_pending_frame', None)
+        if frame is not None:
+            self._process_render_frame(render_data, frame, render_data.warp_buffers)
+        render_data._extraction_done = True
+        render_data._pending_frame = None
+        render_data._pending_products = None
 
     def cleanup(self, render_data: OVRTXRenderData | None) -> None:
         """Release renderer resources. See :meth:`~isaaclab.renderers.base_renderer.BaseRenderer.cleanup`."""