RoboPrec: Enabling Reliable Embedded Computing for Robotics by Providing Accuracy Guarantees across Mixed-Precision Datatypes
Alp Eren Yilmaz, Thomas Bourgeat, Lillian Pentecost, Brian Plancher, Sabrina Neuman
AI summary
Problem
Embedded robotics platforms lack native floating-point support and rely on fixed-point arithmetic, but manually selecting bit precision is error-prone and lacks formal accuracy guarantees, risking numerical instability in safety-critical applications.
Approach
RoboPrec transpiles modern robotics code into an analysis language, performs static error bound verification, and generates optimized fixed-point C or FPGA code with provable accuracy guarantees.
Key results
- Transpiler converts Rust robotics code to analysis DSL with robot-specific optimizations
- Static analysis generates provable worst-case error bounds for mixed- and uniform-precision datatypes
- 32-bit fixed-point code achieves up to 8× speedup over float and 122× over double on embedded processors
- Guaranteed accuracy bounds surpass standard float while enabling successful real-world pick-and-place tasks
Why it matters
Enables power-constrained mobile robots and nano-platforms to run safety-critical control algorithms reliably on low-power microcontrollers and FPGAs without sacrificing numerical accuracy.
Abstract
Mobile robots demand power efficiency as well as accuracy and high performance in their computations. Embedded microcontrollers and FPGAs can consume as much as 1000× less power than large CPUs and GPUs, however, these power-efficient platforms often lack full floating-point support and rely on fixed- point computations to deliver performance. This is a challenge as most robotics software uses floating-point datatypes (double, float) to conservatively ensure accuracy, and prior works that use fixed-point types employ unreliable ad hoc approaches to select the datatype precision (i.e., quantity and allocation of bits). We address this challenge with the RoboPrec framework, where we: (i) develop a transpiler that integrates code transformations and robot-specific code generation with traditional numerical stability analysis methods (which calculate error bounds), and adapts them to be practical for robotics software; and then leverage this to (ii) generate guaranteed-accuracy fixed-point code that is deployable to embedded computing platforms. We use rigid body dynamics, a fundamental robotics workload, as a motivating case study. We find that RoboPrec-generated 32-bit fixed-point code can be up to 8× faster than float and 122× faster than double on embedded processors while, critically, also providing guaranteed accuracy bounds with lower worst-case error than float.