simulation/modules/IsaacLab/docs/source/testing/micro_benchmarks.rst

.. _testing_micro_benchmarks:

Micro-Benchmarks for Performance Testing
========================================

Isaac Lab provides micro-benchmarking tools to measure the performance of asset
setter/writer methods and data property accessors without requiring Isaac Sim.

.. seealso::

   For full-simulation benchmarks (environment stepping, RL training), see
   :ref:`testing_benchmarks`. This page covers method-level micro-benchmarks
   that use mock interfaces.

Overview
--------

The benchmarks use **mock interfaces** to simulate PhysX views, allowing performance
measurement of Python-level overhead in isolation. This is useful for:

- Comparing list vs tensor index performance
- Identifying bottlenecks in hot code paths
- Tracking performance regressions
- Optimizing custom methods

Quick Start
-----------

Run benchmarks using the Isaac Lab launcher:

.. code-block:: bash

   # Run Articulation method benchmarks
   ./isaaclab.sh -p source/isaaclab_physx/benchmark/assets/benchmark_articulation.py

   # With custom parameters
   ./isaaclab.sh -p source/isaaclab_physx/benchmark/assets/benchmark_articulation.py \
       --num_iterations 1000 \
       --num_instances 64 \
       --num_bodies 5 \
       --num_joints 4

Available Benchmarks
--------------------

Asset Method Benchmarks
~~~~~~~~~~~~~~~~~~~~~~~

These benchmark setter and writer methods on asset classes:

.. list-table::
   :header-rows: 1
   :widths: 35 25 40

   * - Benchmark File
     - Asset Class
     - Methods Covered
   * - ``benchmark_articulation.py``
     - ``Articulation``
     - 24 methods (root/joint state, mass props, forces)
   * - ``benchmark_rigid_object.py``
     - ``RigidObject``
     - 13 methods (root state, mass props, forces)
   * - ``benchmark_rigid_object_collection.py``
     - ``RigidObjectCollection``
     - 13 methods (body state, mass props, forces)

Data Property Benchmarks
~~~~~~~~~~~~~~~~~~~~~~~~

These benchmark property accessors on data classes:

.. list-table::
   :header-rows: 1
   :widths: 40 30 30

   * - Benchmark File
     - Data Class
     - Properties
   * - ``benchmark_articulation_data.py``
     - ``ArticulationData``
     - 59 properties
   * - ``benchmark_rigid_object_data.py``
     - ``RigidObjectData``
     - 40 properties
   * - ``benchmark_rigid_object_collection_data.py``
     - ``RigidObjectCollectionData``
     - 40 properties

All benchmarks are located in ``source/isaaclab_physx/benchmark/assets/``.

Command Line Arguments
----------------------

Common Arguments
~~~~~~~~~~~~~~~~

.. list-table::
   :header-rows: 1
   :widths: 20 15 65

   * - Argument
     - Default
     - Description
   * - ``--num_iterations``
     - 1000
     - Number of timed iterations
   * - ``--warmup_steps``
     - 10
     - Warmup iterations (not timed)
   * - ``--num_instances``
     - 4096
     - Number of asset instances
   * - ``--device``
     - ``cuda:0``
     - Device for tensors
   * - ``--mode``
     - ``all``
     - ``all``, ``torch_list``, or ``torch_tensor``
   * - ``--output``
     - auto
     - Output JSON filename
   * - ``--no_csv``
     - false
     - Disable CSV output

Asset-Specific Arguments
~~~~~~~~~~~~~~~~~~~~~~~~

**Articulation benchmarks:**

- ``--num_bodies``: Number of links (default: 13)
- ``--num_joints``: Number of DOFs (default: 12)

**RigidObjectCollection benchmarks:**

- ``--num_bodies``: Number of bodies in collection (default: 5)

Benchmark Modes
---------------

Each method is benchmarked under two input scenarios:

**torch_list**
   Environment/body IDs passed as Python lists. Measures the overhead of
   list-to-tensor conversion, which is common in user code.

**torch_tensor**
   Environment/body IDs passed as pre-allocated tensors. Represents the
   optimal baseline with minimal overhead.

Example output:

.. code-block:: text

   [1/24] [TORCH_LIST] write_root_state_to_sim... 132.02 ± 6.79 µs
   [1/24] [TORCH_TENSOR] write_root_state_to_sim... 65.44 ± 3.06 µs

The comparison shows tensor indices are ~2x faster than list indices.

Output Format
-------------

Console Output
~~~~~~~~~~~~~~

.. code-block:: text

   Benchmarking Articulation (PhysX) with 64 instances, 5 bodies, 4 joints...
   Device: cuda:0
   Iterations: 100, Warmup: 10

   Benchmarking 24 methods...
   [1/24] [TORCH_LIST] write_root_state_to_sim... 132.02 ± 6.79 µs
   [1/24] [TORCH_TENSOR] write_root_state_to_sim... 65.44 ± 3.06 µs
   ...

   ================================================================================
   COMPARISON: Torch_list vs Torch_tensor
   ================================================================================
   Method Name                         Torch_list   Torch_tensor   Speedup
   ------------------------------------------------------------------------
   write_root_state_to_sim               132.02        65.44        2.02x

Export Files
~~~~~~~~~~~~

Results are automatically exported to:

- ``{benchmark_name}_{timestamp}.json`` - Full results with hardware info
- ``{benchmark_name}_{timestamp}.csv`` - Tabular results for analysis

JSON Structure
~~~~~~~~~~~~~~

.. code-block:: json

   {
     "config": {
       "num_iterations": 100,
       "num_instances": 64,
       "device": "cuda:0"
     },
     "hardware": {
       "cpu": "Intel Core i9-13950HX",
       "gpu": "NVIDIA RTX 5000",
       "pytorch": "2.7.0",
       "cuda": "12.8"
     },
     "results": [
       {
         "name": "write_root_state_to_sim",
         "mode": "torch_list",
         "mean_us": 132.02,
         "std_us": 6.79,
         "iterations": 100
       }
     ]
   }

Architecture
------------

The benchmarks use mock interfaces to simulate PhysX views without Isaac Sim:

.. code-block:: text

   ┌─────────────────────┐     ┌──────────────────────┐
   │   Asset Class       │────>│   MockArticulationView│
   │   (Articulation)    │     │   (mock_interfaces)   │
   └─────────────────────┘     └──────────────────────┘
            │
            v
   ┌───────────────────────────┐
   │   MethodBenchmarkRunner   │
   │   (extends BaseIsaacLab-  │
   │    Benchmark)             │
   └───────────────────────────┘
            │
            v
   ┌───────────────────────────┐
   │   Output Backends         │
   │   (json, osmo, omniperf)  │
   └───────────────────────────┘

Key Components
~~~~~~~~~~~~~~

1. **Mock Views** (``isaaclab_physx/test/mock_interfaces/``)

   - ``MockArticulationView`` - Mimics PhysX ArticulationView
   - ``MockRigidBodyView`` - Mimics PhysX RigidBodyView

2. **Benchmark Framework** (``isaaclab/test/benchmark/``)

   - :class:`~isaaclab.test.benchmark.MethodBenchmarkRunner` - Runner extending
     :class:`~isaaclab.test.benchmark.BaseIsaacLabBenchmark` for method-level benchmarks
   - :class:`~isaaclab.test.benchmark.MethodBenchmarkRunnerConfig` - Configuration dataclass
   - :class:`~isaaclab.test.benchmark.MethodBenchmarkDefinition` - Benchmark definition
   - Multiple output backends (JSON, Osmo, OmniPerf)

3. **Module Mocking**

   Each benchmark file mocks Isaac Sim dependencies (``isaacsim``, ``omni``, ``pxr``)
   to allow the asset classes to be instantiated without simulation.

Adding New Benchmarks
---------------------

Adding a Method Benchmark
~~~~~~~~~~~~~~~~~~~~~~~~~

1. Create input generator functions:

.. code-block:: python

   from isaaclab.test.benchmark import MethodBenchmarkRunnerConfig

   def gen_my_method_torch_list(config: MethodBenchmarkRunnerConfig) -> dict:
       return {
           "param1": torch.rand(config.num_instances, 3, device=config.device),
           "env_ids": list(range(config.num_instances)),
       }

   def gen_my_method_torch_tensor(config: MethodBenchmarkRunnerConfig) -> dict:
       return {
           "param1": torch.rand(config.num_instances, 3, device=config.device),
           "env_ids": torch.arange(config.num_instances, device=config.device),
       }

2. Add to the ``BENCHMARKS`` list:

.. code-block:: python

   from isaaclab.test.benchmark import MethodBenchmarkDefinition

   MethodBenchmarkDefinition(
       name="my_method",
       method_name="my_method",
       input_generators={
           "torch_list": gen_my_method_torch_list,
           "torch_tensor": gen_my_method_torch_tensor,
       },
       category="my_category",
   ),

Adding a Property Benchmark
~~~~~~~~~~~~~~~~~~~~~~~~~~~

For data class properties, add to the ``PROPERTIES`` list:

.. code-block:: python

   ("my_property", {"derived_from": ["dependency1", "dependency2"]}),

The ``derived_from`` key indicates dependencies that should be pre-computed
before timing the property access.

Performance Tips
----------------

Based on benchmark results:

1. **Use tensor indices** instead of lists for 30-50% speedup
2. **Pre-allocate index tensors** and reuse them across calls
3. **Batch operations** where possible (e.g., set all joint positions at once)
4. **Mass properties are CPU-bound** - PhysX requires CPU tensors for these

Example optimization:

.. code-block:: python

   # Slow: Create new list each call
   for _ in range(1000):
       robot.write_joint_state_to_sim(state, env_ids=list(range(64)))

   # Fast: Pre-allocate tensor and reuse
   env_ids = torch.arange(64, device="cuda:0")
   for _ in range(1000):
       robot.write_joint_state_to_sim(state, env_ids=env_ids)

Troubleshooting
---------------

Import Errors
~~~~~~~~~~~~~

Ensure you're running through ``isaaclab.sh``:

.. code-block:: bash

   ./isaaclab.sh -p source/isaaclab_physx/benchmark/assets/benchmark_articulation.py

CUDA Out of Memory
~~~~~~~~~~~~~~~~~~

Reduce ``--num_instances``:

.. code-block:: bash

   ./isaaclab.sh -p ... --num_instances 1024

Slow First Run
~~~~~~~~~~~~~~

The first run compiles Warp kernels. Subsequent runs will be faster.