Titan: A Parallel Asynchronous Library for Multi-Agent and Soft-Body Robotics using NVIDIA CUDA

Jacob Austin, Rafael Corrales-Fatou, Sofia Wyetzner, Hod LipsonICRA 2020 · DOI

TL;DR

This paper introduces Titan, a novel C++ robotics simulation library that leverages NVIDIA CUDA for massively parallel, asynchronous simulations of soft-body and multi-agent robots. Titan achieves unprecedented simulation speeds, enabling complex research in areas like reinforcement learning and topology optimization that were previously computationally prohibitive.

What Problem Does This Paper Address?

Simulating complex robotic systems, especially those involving many interacting bodies (multi-agent systems) or deformable materials (soft-body robotics), presents a significant computational challenge. Traditional robotics simulation libraries are often designed for simpler, serial tasks and struggle to scale to the parallelism required for these advanced domains. This limitation hinders research in areas like reinforcement learning, where rapid iteration through many simulations is crucial for training intelligent agents, and in soft robotics, where modeling the intricate internal dynamics of deformable materials is computationally intensive. Furthermore, existing solutions often lack the flexibility to easily integrate new robot designs or perform real-time optimization alongside simulation.

Methods

Titan tackles these challenges with a novel asynchronous computing model and a highly parallelized GPU architecture.

  • Asynchronous CPU/GPU Computation: This is a core innovation. Titan allows the CPU and GPU to operate largely independently, synchronizing only when necessary. This means simulations can run on the GPU while the CPU performs analysis, optimization, or prepares for the next simulation step, minimizing data transfer bottlenecks.
  • CUDA Kernel Design for Parallel Simulations: The library uses a massively parallel integration scheme for kinematics. For soft bodies, it models them as spring-mass systems. The CUDA kernels are designed to alternate updates of springs and masses, allowing for different time resolutions and avoiding synchronization issues.
  • Fast Data Structures for O(1) Insertion/Deletion: To support dynamic robot topologies (e.g., for topology optimization or 3D printing), Titan employs GPU-resident data structures that enable constant-time insertion and deletion of masses and springs. This is achieved through lazy deletion and reference counting.
  • Spring-Mass Modeling: Soft bodies and solids are approximated as lattices of masses connected by springs. Spring constants and mass properties can be derived from real-world material properties, allowing for more realistic simulations.

Datasets

Not discussed in the paper. The paper focuses on the simulation library itself and its performance on synthetic benchmarks and simulated robotic systems.

Key Insights and Ideas

  • Asynchronous Simulation is Key for RL and Optimization: The ability to decouple simulation from optimization on the CPU is a game-changer for reinforcement learning and other iterative optimization tasks. It allows for significantly faster learning cycles.
  • GPU Parallelism Unlocks Soft-Body and Multi-Agent Scale: By effectively mapping the physics of many interacting bodies or deformable materials onto the GPU, Titan can simulate systems orders of magnitude larger than previously feasible.
  • Flexibility Through Abstraction: Titan's spring-mass abstraction and its extensible C++ framework allow users to model a wide variety of robotic systems and add new primitives easily.
  • Performance Over Sophistication (Sometimes): The paper argues that for massive parallelism, a simpler explicit Euler integration scheme with small time-steps on the GPU can outperform more complex, serial solvers on the CPU.

Key Results

  • Massive Performance Gains: Titan achieves dramatic speedups over CPU-based baselines, simulating up to 300 million primitive updates per second.
  • Scalability: Performance scales well with the number of springs, remaining relatively constant even for very large lattices, unlike CPU performance which scales linearly.
  • Realistic Simulations: The library successfully simulates complex scenarios like locomotive worms and multi-body swarms, demonstrating its capability for both soft-body and multi-agent robotics.
  • Efficiency in Topology Optimization: The O(1) insertion/deletion data structures enable rapid topology modifications during simulation, crucial for optimization tasks.

Limitations and Future Work

  • Limitations:
    • The paper acknowledges that while NVIDIA FleX is more feature-rich in some respects, Titan sacrifices some of that for raw performance in large-scale simulations.
  • The current physics solver is an explicit Euler integration, which, while fast, might be less accurate than higher-order methods for certain scenarios.
  • Collision detection is not explicitly detailed as a core feature, though it's mentioned as a potential future addition.
  • Future Work:
    • Adding new CUDA kernels for other time integration methods to potentially increase accuracy.
  • Incorporating more robust collision detection mechanisms.
  • Expanding the library's capabilities for simulating adaptive materials and programmable matter.
  • Leveraging its open-source nature to encourage community contributions and improvements.

Summary updated

BibTeX
@inproceedings{austin2020titan,
  author = {Jacob Austin and Rafael Corrales-Fatou and Sofia Wyetzner and Hod Lipson},
  title = {{Titan: A Parallel Asynchronous Library for Multi-Agent and Soft-Body Robotics using NVIDIA CUDA}},
  booktitle = {IEEE International Conference on Robotics and Automation},
  year = {2020},
  doi = {10.1109/icra40945.2020.9196808},
}
Figure