Performance & Hardware Validation
GATO achieves 18–21× speedup over CPU baselines and 1.4–16× speedup over GPU baselines as batch size increases, covering the under-served regime of tens to low-hundreds of parallel solves at real-time rates.
Abstract
While Model Predictive Control (MPC) delivers strong performance across robotics applications, solving the underlying (batches of) nonlinear trajectory optimization (TO) problems online remains computationally demanding. Existing GPU-accelerated approaches typically (i) parallelize a single solve to meet real-time deadlines, (ii) scale to very large batches at slower-than-real-time rates, or (iii) achieve speed by restricting model generality (e.g., point-mass dynamics or a single linearization). This leaves a large gap in solver performance for many state-of-the-art MPC applications that require real-time batches of tens to low-hundreds of solves. As such, we present GATO, an open source, GPU-accelerated, batched TO solver co-designed across algorithm, software, and computational hardware to deliver real-time throughput for these moderate batch size regimes. Our approach leverages a combination of block-, warp-, and thread-level parallelism within and across solves for ultra-high performance. We demonstrate the effectiveness of our approach through a combination of: simulated benchmarks showing speedups of 18-21x over CPU baselines and 1.4-16x over GPU baselines as batch size increases; case studies highlighting improved disturbance rejection and convergence behavior; and finally a validation on hardware using an industrial manipulator. We open source GATO to support reproducibility and adoption.
Key Results
(Left) Solve times for 6-DoF manipulator motions while varying the batch size (M) and underlying solver. N=64 for all solves. GATO shows far improved scalability as compared to state-of-the-art CPU and GPU solutions. (Right) A heat map of solve times while varying both batch size (M) and time horizon (N). GATO is able to reach kHz control rates for real-time iterations of large batches (512) of short horizon (N=8) trajectories, as well as smaller batches (32) of longer horizon trajectories (N=128), showing the flexibility of the design.
Figure-8 tracking task, with an external disturbance applied at the end effector. (Left) Bar chart shows tracking error, scatter plot shows average total joint velocities. Increasing GATO's batch size enables increased disturbance rejection, lowering tracking error and joint velocities until the increased latency from a larger batch size outweighs the optimality gains. (Right) End-effector trajectories realized during this experiment when 50N of external force is applied at the end effector, again showing that modest batch sizes lead to the best performance.
(Left) Cumulative density function of the solve times for a trajectory length N=16 for GATO across different batch sizes and varied pendulum configurations. For each batch size, the solver accounts for 100 disturbance scenarios. We see how larger batch sizes enable more accurate unmodeled disturbance rejection. (Right) Hardware experiment showing the solver successfully (M=32) and unsuccessfully (M=1) accounting for the time-varying unmodeled disturbance and reach the targets.
Method
GATO solves batches of nonlinear trajectory optimization problems using a GPU-accelerated Sequential Quadratic Programming (SQP) approach co-designed across algorithm, software, and hardware. At each SQP iteration, it:
- Batch initialization: Initializes all trajectories in parallel across GPU threads, amortizing setup cost over the entire batch.
- Parallelized KKT formation & factorization: Exploits block-, warp-, and thread-level GPU parallelism both within a single solve (across time steps) and across solves (across the batch) to form and factor the KKT system via Schur complement decomposition with no CPU-GPU data transfer in the inner loop.
- Line search & convergence: Applies a GPU-resident line search with merit function evaluation, enabling fast convergence and strong disturbance rejection without falling back to CPU.
This co-design fills the critical gap between single-solve real-time methods and large-batch offline solvers, enabling scalable edge MPC for manipulation and other robotics applications.
Supported Robot Systems
GATO ships with plant models for two robot arms. Additional systems can be added by implementing
_plant.cuh and _grid.cuh (see gato/dynamics/).
| Robot | DOF | Notes |
|---|---|---|
| KUKA iiwa14 | 7 | Industrial manipulator; grid dynamics pre-generated via GRiD |
| Neubrex Indy7 | 6 | Collaborative robot; grid dynamics pre-generated via GRiD |
Configurable horizon lengths: 8, 16, 32, 64, 128 knot points (set via -DKNOTS at build time).
Quick Start
Setup (Docker + uv)
git clone https://github.com/A2R-Lab/GATO.git
cd GATO
./tools/install.sh # install Docker and uv
./tools/docker.sh # build image and enter containerBuild the CUDA Solver
./tools/build.sh # default: iiwa14 + indy7, knots 8/32/128Custom Build Options
mkdir -p build && cd build
cmake -DPLANT="iiwa14" -DKNOTS="16;64" ..
cmake --build . --parallelBuilt Python extension modules are written to python/bsqp/ as bsqpN{N}_{plant}.so.
See examples/ for Jupyter notebooks demonstrating MPC with GATO.
