⚡ electrical engineering

GPU-Accelerated Direct Transcription-Based Nonlinear Model Predictive Control

This paper presents a GPU-accelerated nonlinear model predictive control framework that utilizes a parametric interior-point formulation to exploit the fixed structure of transcribed optimal control problems, thereby eliminating redundant computations and achieving over an order-of-magnitude speedup in real-time solve times compared to existing methods.

Original authors: Evelyn Gondosiswanto, Joshua L. Pulsipher

Published 2026-06-04

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Evelyn Gondosiswanto, Joshua L. Pulsipher

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are the captain of a massive, complex ship navigating through a storm. You need to steer the ship perfectly to avoid rocks and reach your destination. To do this, you constantly run a simulation in your head: "If I turn the wheel this way, where will the ship be in 10 minutes? If I turn it that way, where will it be?"

This is what Nonlinear Model Predictive Control (NMPC) does. It's a sophisticated autopilot system used in everything from chemical factories to self-driving cars. It constantly asks, "What is the best thing to do right now to get the best result later?"

However, there's a catch. The real world is messy and non-linear (like a ship in a storm, not a car on a straight road). Calculating the perfect answer for these messy situations is like trying to solve a giant, shifting jigsaw puzzle. It takes a lot of brainpower and time. If the computer takes too long to solve the puzzle, the ship might crash before the answer is ready.

The Problem: Rebuilding the Puzzle Every Time

In traditional systems, every time the captain gets a new piece of information (like a new wave hitting the ship), the computer throws away the old puzzle and builds a brand new one from scratch to find the new best move.

Even though the puzzle pieces are almost identical to the last one—just slightly shifted—the computer wastes time re-assembling the frame, sorting the edges, and figuring out how the pieces fit together. This "rebuilding" takes up so much time that it slows down the whole process.

The Solution: A GPU-Powered "Smart Reuse" System

The authors of this paper, Evelyn Gondosiswanto and Joshua Pulsipher, built a new system that acts like a master puzzle master who never throws away the frame.

They used a special type of super-computer chip called a GPU (Graphics Processing Unit). Think of a CPU (the brain in your laptop) as a single genius chef who cooks one dish at a time very carefully. A GPU is like a massive army of 10,000 line cooks who can chop vegetables, stir pots, and plate food all at the exact same time.

Their new framework does two clever things:

The "One-Time Blueprint" (Symbolic Factorization):
Instead of rebuilding the puzzle frame every time, the system builds the frame once at the very beginning. It figures out exactly how the pieces connect and creates a "blueprint" of the structure. Because the underlying rules of the ship (or chemical plant) don't change, this blueprint stays valid forever.
- Analogy: Imagine you have a LEGO castle. Every time you want to change the color of the roof, you don't tear the whole castle down. You just keep the castle structure and swap out the roof bricks. The paper's system does this for complex math problems.
The "Massive Army" (GPU Parallelization):
Once the blueprint is set, the system uses the GPU's army of 10,000 cooks to calculate the new numbers for the puzzle pieces simultaneously. Because they are all working on the same structure at the same time, they finish the job incredibly fast.

The Results: Speeding Up the Autopilot

The researchers tested this new system on two real-world scenarios:

A Distillation Column: A giant tower used to separate chemicals (like separating alcohol from water).
A Heated Plate: A metal sheet where they needed to control the temperature in specific spots to keep it even.

They compared their new "Smart Reuse" system against the old ways of doing things (using standard computer brains or older GPU methods that still rebuilt the puzzle every time).

The findings were dramatic:

The new system was 10 times faster (an order of magnitude) in total time for the whole mission.
For the actual math-solving part, it was up to 94% faster than the baseline.
It achieved this by cutting out the "rebuilding" time and letting the GPU army focus purely on the calculations.

Why This Matters

The paper claims that by realizing we don't need to rebuild the "skeleton" of the problem every time, and by using the massive parallel power of GPUs, we can make these complex autopilots fast enough to handle even more difficult, real-time tasks. It's like upgrading a ship's autopilot from a slow, manual calculator to a super-fast, parallel-processing brain that never forgets the map.

In short: They figured out how to stop computers from wasting time re-drawing the map every time they take a step, allowing them to use super-fast parallel processors to navigate complex, real-world challenges much more quickly.

Technical Summary: GPU-Accelerated Direct Transcription-Based Nonlinear Model Predictive Control

Problem Statement

Nonlinear Model Predictive Control (NMPC) is essential for controlling constrained multivariable systems with nonlinear dynamics that linear models cannot accurately capture. However, real-time NMPC implementation is hindered by the computational burden of repeatedly solving large-scale nonlinear programs (NLPs) derived from optimal control problems (OCPs). While GPU acceleration has emerged as a promising solution for large-scale NLPs, existing GPU-based NMPC workflows suffer from a critical limitation: they reconstruct structurally identical OCPs at every solve step.

Although successive NMPC solves differ only in updated system measurements or reference trajectories, current approaches fail to exploit this fixed problem structure. Consequently, they incur substantial overhead by repeatedly performing structure-dependent computations, such as symbolic factorization in sparse linear solvers, even though these structures remain invariant across iterations. This repeated initialization creates a performance bottleneck that limits the feasibility of real-time NMPC applications.

Methodology

The authors propose a second-order, GPU-accelerated NMPC framework based on direct transcription and parametric interior-point methods. The core of the methodology involves three technical pillars:

1. Parametric Modeling Abstraction

The framework utilizes the InfiniteSIMD-NLP abstraction to transcribe OCPs. Instead of treating every discretization point as a unique constraint instance, the approach identifies recurrent algebraic patterns. By separating the fixed algebraic structure from the data inputs (parameters), the framework enables the reuse of structure-dependent computations. This abstraction is implemented within the Julia packages InfiniteOpt.jl and InfiniteExaModels.jl.

2. Parametric Interior-Point Algorithm

The authors formalize a parametric interior-point algorithm designed for efficient re-solving of transcribed OCPs. Key algorithmic features include:

Lifted-KKT Reformulation: To ensure the condensed KKT system is positive-definite (required for sparse Cholesky factorization), the equality constraints are relaxed, and the system is lifted into a higher-dimensional space.
Decoupling of Symbolic and Numerical Factorization: The framework explicitly separates the symbolic factorization (determining sparsity structure and permutation matrices) from the numerical factorization (computing numerical values).
- Symbolic Factorization: Performed only once during the initial NMPC solve. The resulting permutation matrix ( $P$ ) and sparsity structure ( $S_L$ ) are cached.
- Numerical Factorization: Repeatedly performed for each interior-point iteration and NMPC step using the cached structural information, accounting only for parametric changes in the KKT system.
Warmstarting: The algorithm utilizes previous solutions to initialize subsequent solves, reducing the number of outer and inner loop iterations required for convergence.

3. Software Implementation

The framework is implemented in Julia, leveraging:

InfiniteOpt.jl: For high-level infinite-dimensional modeling.
InfiniteExaModels.jl: For transcribing models into SIMD-based ExaModels suitable for GPU execution.
MadNLP.jl and cuDSS: For executing the interior-point algorithm and solving linear systems via sparse Cholesky factorization on NVIDIA GPUs.
The implementation supports in-place backend updates via two APIs: warmstart_backend_start_values (to reuse solution vectors) and set_parameter_value (to update problem data without rebuilding the solver backend).

Key Contributions

The paper outlines four primary contributions:

Parametric Modeling Abstraction: Development of a modeling abstraction that leverages recurrent algebraic structures for efficient parallelized computations on GPUs (and CPUs).
Parametric Interior-Point Algorithm: Formalization of a GPU-optimized algorithm that exploits fixed problem structures to enable efficient re-solving of transcribed OCPs.
Software Implementation: A complete software implementation via InfiniteOpt.jl and InfiniteExaModels.jl that constructs the OCP structure once and reuses it across re-solves, supporting both GPU and CPU workflows.
Benchmarking: Comprehensive evaluation against state-of-the-art CPU and GPU configurations, demonstrating significant reductions in solve times.

Results

The framework was evaluated on two benchmarks: a distillation column (dynamic optimization) and a 2D heated plate (PDE-constrained optimization). The results were compared against various configurations, including JuMP with Ipopt (CPU), OptimalControl.jl (GPU), and MPCGPU (manual CUDA implementation).

Total NMPC Run Times: The proposed framework achieved an order-of-magnitude speedup in total NMPC run times compared to baseline CPU and GPU workflows.
Per-Iteration Solve Times: On the GPU, the framework achieved up to a 94% reduction in per-iteration solve times compared to the baseline.
- For the distillation benchmark, the InfiniteExaModels + MadNLP + cuDSS configuration with Warmstart (WS) and Parameter Update (PU) reduced total time to 3.00 seconds, compared to 21.91 seconds for the base case.
- For the PDE plate benchmark, the same configuration reduced total time to 3.28 seconds, compared to 37.30 seconds for the base case.
Comparison with MPCGPU: While the manually coded MPCGPU workflow was slightly faster on the distillation benchmark (2.44s vs 3.00s) due to the absence of model construction and automatic differentiation overhead, the proposed framework offers a general, high-level modeling interface. The results indicate that the overhead of reconstructing the backend and performing symbolic factorization at every iteration (as seen in OptimalControl.jl without parameter reuse) is the primary performance bottleneck, which the proposed framework successfully eliminates.

Significance and Claims

The paper claims that the proposed framework effectively addresses the performance bottleneck of repeated problem initialization in GPU-accelerated NMPC. By exploiting the fixed structure of transcribed OCPs and reusing structure-dependent computations (specifically symbolic factorization), the framework significantly expands the envelope of real-time NMPC applications.

The authors emphasize that the improvements are primarily driven by reduced per-iteration solve times, demonstrating that the combination of second-order methods, GPU parallelization, and structural reuse is highly effective. The work highlights that while data-driven methods and decomposition strategies exist, they often face generalization or implementation challenges; in contrast, this approach retains the rigor of mechanistic models while achieving computational efficiency comparable to or exceeding specialized, manually coded GPU solvers, but with the flexibility of a high-level algebraic modeling language.