FAME-QP GPU solver for model predictive control reports lower latency

A new paper presents FAME-QP, a GPU-accelerated solver for dense quadratic programs that arise in linear model predictive control (MPC).
The design rests on a few ideas. FAME-QP combines constraint-dependent operator representations with fused single-kernel and two-kernel iterations, which are replayed through CUDA graphs. It chooses its own execution configuration automatically, using device calibration and problem-specific timing. It also probes a cached operator bank to pick the initial penalty, and it updates operators lazily when the problem matrices change.
For evidence, the authors point to numerical benchmarks and to simulated humanoid and quadrotor control experiments. They say these show reduced latency relative to competing GPU solvers while solution accuracy and control performance are maintained.
The text gives no numeric latency figures, speedup factors or accuracy values, and it does not name the competing GPU solvers. It names no authors or institutions. The experiments it describes are simulated, and it mentions no real-hardware results.
Key facts
- FAME-QP is a GPU-accelerated solver for dense quadratic programs arising in linear model predictive control.
- It combines constraint-dependent operator representations with fused single- and two-kernel iterations replayed through CUDA graphs.
- It selects its execution configuration automatically through device calibration and problem-specific timing.
- It probes a cached operator bank to choose the initial penalty and updates operators lazily when problem matrices change.
- The authors report reduced latency versus competing GPU solvers in numerical benchmarks and simulated humanoid and quadrotor control, with accuracy and control performance maintained.
Why it matters
Latency is the stated target: the headline claim is lower latency than other GPU solvers. The technical route is to cut per-iteration overhead by fusing iterations into one or two kernels and replaying them through CUDA graphs, and to avoid rebuilding work by caching operators and updating them lazily when the problem matrices change.
Who it affects
The work speaks to people who solve dense quadratic programs inside linear MPC on GPUs. The test cases it names are humanoid and quadrotor control, so robotics and control engineers are the closest audience.
How to use it
The text mentions no code release, license or availability, so there is nothing to download or run from it. Practitioners would need the full paper to judge how the solver is set up and called. The solver is described as selecting its own execution configuration, so tuning by hand is not part of the pitch.
How solid is it
The claims are the authors' own, drawn from an abstract-length description. They cite numerical benchmarks and simulated humanoid and quadrotor experiments. No numeric latency figures, speedup factors or accuracy values are given, and the competing GPU solvers are not named, so the size of the improvement cannot be judged from this text.
Risks and caveats
The experiments are simulated; no real-hardware (physical robot) results are mentioned. No hardware (GPU model) used in the benchmarks is specified. No comparison against CPU solvers is mentioned. The claim of reduced latency is relative to competing GPU solvers only, and it is not quantified here.