Sampling-based controllers pick each action by imagining thousands of possible futures, scoring them, and averaging the best. The robot simulates many random variations of its next second of motion, rates each one with a cost function, and blends them, giving more weight to the good ones. This approach handles rough, discontinuous objectives that gradient-based solvers struggle with. Today it runs only on graphics processors that draw tens to hundreds of watts. Small robots that need online adaptation are therefore stuck with a poor choice. They can either carry a GPU they cannot power, or replace online planning with a frozen neural network that fails when the world drifts from simulation.
We propose to rewrite the sampling controller so that it never stores its samples. The random perturbations are regenerated on demand from a counter-based random number generator. The cost-weighted average is accumulated in a single streaming pass, using the running-maximum trick that makes "online softmax" possible. The memory needed then no longer grows with the number of samples. We would then co-design this streaming algorithm jointly with a small FPGA datapath (a reconfigurable chip whose circuits are laid out for one task), choosing four things together: the number of samples, the planning horizon, the numeric precision of each pipeline stage, and the degree of hardware parallelism. The objective of that joint search is measured closed-loop control performance under a power budget. The claim is that this yields a controller that keeps the adaptivity of online sampling at roughly the power and latency envelope where only offline-distilled networks run today.
Core Claim
Model Predictive Path Integral control (MPPI) is the standard sampling controller, formalized in Model Predictive Path Integral Control: From Theory to Parallel Computation. It updates a nominal control sequence $u$ by
$$u \leftarrow u + \sum_{k=1}^{K} w_k\,\delta u_k, \qquad w_k = \frac{\exp(-(S_k - \min_j S_j)/\lambda)}{\sum_{j}\exp(-(S_j - \min_j S_j)/\lambda)},$$
where the terms are defined as follows. $K$ is the number of sampled rollouts. $\delta u_k$ is the random perturbation added to the nominal sequence for rollout $k$. $S_k$ is that rollout's accumulated cost. $\lambda$ is a temperature that sets how sharply good rollouts dominate.
GPU implementations materialize all $K$ perturbations and costs before aggregating. Two observations remove that requirement.
The first is about the weights. The normalized weighted sum can be computed in one pass by keeping a running minimum cost, a running normalizer, and a running weighted sum of perturbations, and rescaling the last two whenever a new minimum appears.
The second is about the perturbations. If each $\delta u_k$ comes from a counter-based generator keyed by $(k, t)$, where $t$ is the timestep within the horizon, the perturbation never needs to be stored. On-chip state is then a constant number of length-$H$ control buffers, where $H$ is the horizon, regardless of $K$.
The second structural fact concerns precision. The update depends only on cost differences relative to the minimum, scaled by $\lambda$. This suggests that different parts of the pipeline tolerate very different amounts of rounding error. Dynamics rollouts may tolerate narrow fixed-point arithmetic, while cost accumulation near the minimum may need more. This is a hypothesis we will measure, not assume.
Our central hypothesis has three parts. Choosing $K$, $H$, the per-stage bit widths, and the parallelism jointly, against closed-loop task cost, will find designs that a sequential "tune the controller, then compile it" workflow misses. Those designs will run within the power class of the hardware-synthesized neural controllers of Hardware Neural Control of CartPole and F1TENTH Race Car on the same Zynq-7020 chip. Under dynamics mismatch and runtime-specified constraints, they will clearly beat those neural controllers.
Relation to Prior Work
Three papers motivate the gap by co-designing predictive control with hardware, all for deterministic solvers acting on a single trajectory.
Automatic Software and Computing Hardware Co-design for Predictive Control jointly searches sampling period, horizon, parallelism, and bit precision for fast-gradient linear MPC on a Zynq. It shows that control parameters set the problem's conditioning and therefore the hardware cycles needed.
Parallel MPC for Real-Time FPGA-based Implementation runs six small quadratic sub-problems in parallel on an FPGA. Nonlinear predictive control on a heterogeneous computing platform partitions an interior-point solver's linear algebra between an ARM core and an FPGA.
None of the three touches random rollouts, cost-weighted aggregation, or sample counts in the thousands. We reuse the first paper's methodology, derivative-free bi-objective search, and apply it to a structurally different workload.
Three sampling-control papers supply the algorithm and show its software-only status. Model Predictive Path Integral Control runs on desktop GPUs. STORM batches manipulator kinematics as GPU tensors. On the Benefits of GPU Sample-Based Stochastic Predictive Controllers for Legged Locomotion runs 10,000 JAX rollouts in about 2 ms on a roughly 30 W mobile GPU. All three store full sample tensors and treat the hardware as fixed.
A fourth sampling-control paper constrains the design. Safe Beyond the Horizon shows that resampling with neural barrier functions cuts sample needs by 5x and reaches over 70 Hz on a laptop CPU. Clever sampling can therefore substitute for raw throughput, and any hardware advantage we claim must survive that comparison.
The closest competitor in spirit is Hardware Neural Control of CartPole and F1TENTH Race Car. It distills nonlinear MPC into a pruned, quantized multilayer perceptron, compiles it with hls4ml, and runs at 1 kHz with under 4 µs latency and about 12–13 mW of logic power. Its authors acknowledge that the network degrades when friction differs from simulation. That limitation is the regime our proposal targets. We keep online optimization rather than replacing it.
Research Program
We would build an MPPI datapath for the Zynq-7020 with four parts. The first is a bank of counter-based Gaussian noise generators. The second is a set of pipelined dynamics-and-cost rollout cores, written in high-level synthesis C++. The third is a streaming log-sum-exp aggregator. The fourth is an optional warm-start port that accepts a nominal sequence from a small on-chip network. This port lets the search trade sample count against the quality of the starting guess.
Each design point is specified by eight parameters: $K$, $H$, $\lambda$, the noise scale, separate bit widths for the dynamics, cost, and aggregation stages, and the number of parallel rollout cores. A design point is scored on two objectives. The first is closed-loop cost, averaged over a fixed set of initial conditions and model-mismatch draws in simulation. The second is estimated power.
Synthesis takes minutes per candidate, so the search runs in two stages. A fast analytical latency and resource model, calibrated on a few dozen synthesized points, is used inside a BiMADS-style derivative-free search. Only Pareto-front candidates are then synthesized and measured on the board.
The analysis will report three things. The first is which pipeline stages are precision-sensitive. The second is how the optimal $K$ shifts with the power budget. The third is how much the streaming reformulation, as opposed to precision tuning, contributes to the result.
Baselines
The naive reference point is the same MPPI algorithm in plain C on the Zynq's ARM Cortex-A9. It uses identical dynamics and costs, with $K$ and $H$ tuned to meet the control period. This shows what the chip delivers with no hardware design at all. For context, Paluch et al. report that their CPU-run nonlinear MPC maxed out at 10 Hz on F1TENTH.
The strongest existing method on this exact hardware and these tasks is the hls4ml neural controller of Hardware Neural Control of CartPole and F1TENTH Race Car. Its reported results are a 1 kHz control rate, under 4 µs latency, and 12 mW core logic power on CartPole. On F1TENTH it reports 13 mW logic power, under 3 W total system power, and laps 20% faster than Pure Pursuit. We will retrain it from the public Neural-Control-Tools code, using the same expert, the same simulation data budget, and the same chip. We will also give it a matched effort for domain randomization during training, so that its robustness is not understated.
Beating it means two things. Under nominal dynamics we must match its task performance within a few percent at comparable power. Under friction or mass shifts outside its training range, and under obstacles specified at runtime, we must post clearly higher success rates and lower tracking cost.
The third baseline is GPU MPPI on a Jetson-class module, following the JAX setup of Turrisi et al. Its sample count is tuned to the same control period and it uses the same costs. This anchors the throughput-per-watt comparison. We found no reported result on Lacuna for GPU MPPI on CartPole or F1TENTH, so we will measure it ourselves.
The fourth baseline is "just HLS": the straightforward MPPI C code with materialized noise and cost arrays, compiled with default high-level synthesis pragmas and uniform 32-bit fixed point.
Three ablations isolate the key ingredients. The first swaps streaming aggregation for materialized buffers. The second swaps per-stage precision for uniform precision. The third swaps the closed-loop search objective for an open-loop proxy, namely solver cost per iteration. For the search method itself, Khusainov et al. report that BiMADS reached 8.71 s settling time versus 10.87 s for Latin hypercube sampling at an FPGA resource limit of 0.1. We will rerun this comparison on our design space.
Why not just…?
Why not just use a mobile GPU? It works, and Turrisi et al. show it works well on a 21 kg quadruped. However, roughly 30 W is out of reach for small platforms whose whole electronics budget is a few watts, the regime Paluch et al. target. The experiment that settles this is energy per control update and closed-loop cost at matched control period. If the GPU's energy per update is within a small factor of the FPGA's, the custom design is not worth building, and we will say so.
Why not just distill the planner into a quantized network? This is the most serious threat. Under nominal dynamics the distilled network will likely win on power and latency. Our claim rests entirely on mismatch and on new constraints at runtime, which Paluch et al. themselves name as weaknesses. Diffusion-Based Approximate MPC adds that simple regression struggles when good actions are multi-modal. The friction and mass sweeps, including a domain-randomized network, decide this. If the randomized network matches us across the sweep, the proposal narrows to the warm-started hybrid, or fails.
Why not just run fewer, smarter samples on the ARM core? Safe Beyond the Horizon shows that 5x sample savings are possible algorithmically. On CartPole, a few hundred samples on the ARM core may suffice. We will therefore report the ARM baseline at its best sample count. We will also report the sample count at which closed-loop cost saturates. The hardware case holds only where that saturation point lies beyond what the ARM core can evaluate in one control period, which is likely on F1TENTH with tire dynamics.
Why not just compile standard MPPI with high-level synthesis? Materialized noise and cost arrays scale memory linearly with $K$ and quickly exhaust a Zynq-7020's on-chip memory. Khusainov et al. also observed that naive parallelism on an FPGA does not scale monotonically. The "just HLS" baseline and the streaming ablation measure this directly.
Proposed Experiments
We start in simulation with CartPole and F1TENTH, using the dynamics models from the Neural-Control-Tools repository. We then move to the physical CartPole and 1/10-scale F1TENTH car at 1 kHz and race-rate control respectively.
Metrics are closed-loop tracking cost, swing-up and balance success, lap time, and constraint violations. On the hardware side we measure latency, core and total power, and energy per update.
Stress conditions sweep three things. Floor and tire friction and pole mass are varied beyond the network baseline's training range. Track obstacles are introduced at runtime, which the neural controller cannot represent without retraining.
The decisive check is the Pareto front of closed-loop cost under mismatch against measured power. The proposal succeeds if the co-designed streaming controller dominates the distilled network under mismatch, while staying within an order of magnitude of its logic power. It must also dominate the ARM and "just HLS" baselines at equal power. It fails if a domain-randomized distilled network or a best-tuned ARM sampler reaches the same front.
References
- Model Predictive Path Integral Control: From Theory to Parallel Computation
- Hardware Neural Control of CartPole and F1TENTH Race Car
- Automatic Software and Computing Hardware Co-design for Predictive Control
- Parallel MPC for Real-Time FPGA-based Implementation
- Nonlinear Predictive Control on a Heterogeneous Computing Platform
- STORM: An Integrated Framework for Fast Joint-Space Model-Predictive Control for Reactive Manipulation
- On the Benefits of GPU Sample-Based Stochastic Predictive Controllers for Legged Locomotion
- Safe Beyond the Horizon: Efficient Sampling-based MPC with Neural Control Barrier Functions
- Diffusion-Based Approximate MPC: Fast and Consistent Imitation of Multi-Modal Action Distributions