💻 computer science

Floating-point autotuning with customized precisions

This paper presents PROMISE, an automated precision tuning tool that utilizes a containerized, parallel search framework to identify optimal mixed-precision floating-point configurations for numerical applications, demonstrating that significant performance and efficiency gains are achievable by reducing precision without compromising accuracy.

Original authors: Xinye Chen, Thibault Hilaire, Fabienne Jézéquel

Published 2026-06-09

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Xinye Chen, Thibault Hilaire, Fabienne Jézéquel

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 a chef trying to bake a perfect cake. For years, you've been using the most expensive, high-precision measuring cups available (let's call them "Gold Cups") for every single ingredient, from the flour to a pinch of salt. You do this because you're afraid that if you use a cheaper cup, the cake might collapse.

But what if you realized that for the flour, a rough scoop is fine, but for the vanilla extract, you absolutely need the Gold Cup? If you used Gold Cups for everything, you'd be wasting money and time, even though the cake would taste the same.

This is exactly the problem computer scientists face with floating-point numbers (the way computers handle decimals). For decades, computers have used a "Gold Cup" standard called Double Precision (FP64) for almost every calculation. It's incredibly accurate, but it's also heavy, slow, and energy-hungry.

This paper introduces a new version of a tool called PROMISE (which stands for PRecision OptiMISE). Think of PROMISE as a smart, automated sous-chef that tastes your cake (runs your code) and tells you exactly which ingredients need the Gold Cup and which ones can be measured with a cheap plastic spoon.

Here is how the paper explains their new approach, broken down into simple concepts:

1. The Problem: One Size Does Not Fit All

Modern computer chips (like those in your phone or graphics cards) are getting better at doing math with "smaller" numbers (like FP16 or even custom 8-bit formats). These small numbers are like using a plastic spoon: they are fast and use very little energy. However, if you use them for everything, your results might become garbage (the cake burns).

The challenge is finding the perfect mix: using the "plastic spoons" where it's safe, and the "Gold Cups" only where it's absolutely necessary.

2. The Old Way vs. The New Way

The Old Way: Previous tools could only switch between a few standard sizes (like switching between a teaspoon and a tablespoon). They couldn't invent new sizes.
The New Way (Customized Precision): The authors upgraded PROMISE to allow custom-sized cups. Imagine you could ask for a measuring tool that is exactly 5 bits for the "whole number" part and 2 bits for the "decimal" part. This is crucial for new hardware like FPGAs (reconfigurable chips) that let you design your own math rules.

3. How PROMISE Works: The "Delta Debugging" Game

How does the tool know which variables (ingredients) can be downsized? It uses a clever game called Delta Debugging.

Imagine you have a line of 100 ingredients. You want to know which ones can be measured with a plastic spoon.

Start High: You measure everything with the Gold Cup first to get a perfect reference cake.
The Guess: You try swapping half the ingredients to plastic spoons.
The Taste Test: You bake the cake again.
- If the cake tastes the same (the math is still accurate enough), you keep the plastic spoons and try swapping more ingredients.
- If the cake is ruined, you know you swapped too many. You go back and try swapping fewer.
The Result: The tool quickly narrows down the list, finding the exact minimum number of Gold Cups needed to save the cake, while using plastic spoons for the rest.

4. The "Magic Glasses" (CADNA)

To know if the cake is "ruined" without actually baking it a million times, PROMISE uses a library called CADNA. Think of CADNA as a pair of magic glasses that the computer wears while it cooks. These glasses don't just see the numbers; they see the uncertainty or "noise" in the numbers. They can tell, "Hey, this calculation is so sensitive that even a tiny plastic spoon error will ruin the result," or "This calculation is so robust, a plastic spoon is perfectly fine."

5. The "Factory" (Benchmarking Framework)

Running these taste tests takes a lot of time. To speed things up, the authors built a containerized factory.

Imagine you have 100 different recipes (algorithms) to test.
Instead of testing them one by one in a single kitchen, they put each recipe in its own Docker container (a self-contained kitchen unit).
They run 6 of these kitchens at the exact same time on a powerful server.
Result: What used to take 13 hours now takes only 3 hours. It's like having a team of chefs working in parallel instead of one chef working alone.

6. What They Found (The Results)

The team tested this on various "recipes," including:

Neural Networks (teaching computers to recognize images).
Thermal Simulations (figuring out how heat moves through a computer chip).
Medical Imaging (tracking particles in videos).
Linear Algebra (solving complex math equations).

The Big Discovery:
They found that for most of these programs, the standard "Gold Cup" (Double Precision) is massive overkill.

43% of the variables could be calculated using 32-bit precision (a medium-sized cup) or smaller.
28% could be calculated using 16-bit precision or even smaller (tiny plastic spoons).
In some cases, they could use custom 8-bit formats (like the E5M2 format mentioned in the paper) for about 23% of the variables without ruining the accuracy.

Summary

The paper doesn't claim to have invented a new cake recipe or a new medical treatment. Instead, it offers a better way to measure ingredients.

By upgrading the PROMISE tool to handle custom-sized measuring cups and running the tests in a parallel "factory," the authors showed that we can make computer programs much faster and more energy-efficient without sacrificing accuracy. We just need to stop using the Gold Cup for everything and start using the right tool for the right job.

Technical Summary: Floating-point Autotuning with Customized Precisions

Problem Statement
Reduced-precision arithmetic offers significant potential to improve performance, memory usage, and energy efficiency in numerical applications, particularly as hardware accelerators (e.g., GPUs, FPGAs) increasingly support non-standard and low-precision formats. However, determining the optimal precision configuration for a specific application is challenging. Standard double precision (FP64) is often over-provisioned, yet blindly reducing precision can compromise numerical stability and accuracy. Existing precision tuning tools are often limited to standard IEEE 754 formats (FP16, FP32, FP64) or lack the flexibility to explore customized bit-width configurations (e.g., specific exponent and significand sizes) required by emerging hardware. Furthermore, the computational cost of exploring the vast space of mixed-precision configurations for large codebases remains a barrier to practical deployment.

Methodology
The authors propose an enhanced version of PROMISE (PRecision OptiMISE), an automated precision tuning tool based on delta debugging and Discrete Stochastic Arithmetic (DSA). The methodology integrates three core components:

Customized Precision Emulation via FloatX: The tool is extended to support user-defined floating-point formats by integrating FloatX, a C++ header-only library. Unlike standard libraries that fix exponent/significand sizes or rely on memory-based allocation (like MPFR), FloatX allows users to specify exact bit allocations for the exponent ( $e$ ) and significand ( $t$ ). PROMISE leverages this to emulate non-standard formats (e.g., E5M2, E4M3) and custom configurations within a unified mixed-precision framework. To ensure realistic emulation, the authors implemented custom-precision versions of mathematical functions (e.g., sin, exp) using C++ function overloading, ensuring inputs and outputs are rounded to the target precision before and after computation.
Numerical Validation via CADNA: PROMISE utilizes the CADNA library, which implements DSA to estimate the number of correct significant digits in computations. By executing code with random rounding modes, CADNA provides a statistical estimate of numerical accuracy and detects instabilities. This allows PROMISE to validate whether a reduced-precision configuration satisfies user-defined accuracy constraints (e.g., a specific number of correct digits) without requiring a ground-truth reference solution, thereby avoiding the unreliability of using uniform FP64 as a reference for lower-precision comparisons.
Delta Debugging Search Strategy: The tool employs a delta debugging algorithm to systematically search for the lowest precision configuration. The search starts from a high-precision baseline and iteratively lowers the precision of variables. If a configuration satisfies the accuracy requirement, the search continues in that direction; otherwise, it backtracks. The authors implement a multi-level strategy where precision types are sorted by unit roundoff, and delta debugging is applied iteratively between consecutive pairs of types.
Containerized Benchmarking Framework: To address the high computational cost of the search, the authors developed a containerized benchmarking framework. This framework wraps PROMISE in a parallelized pipeline, supporting both local parallelism (via GNU Parallel) and distributed execution (via an MPI-based Python scheduler). This allows for the concurrent execution of multiple algorithm kernels across different parameter configurations, significantly reducing total runtime.

Key Contributions

Extended PROMISE with Customized Formats: The paper introduces a new version of PROMISE that enables the specification of floating-point arithmetic by defining the number of bits for the significand and exponent. This allows users to explore non-standard precision configurations tailored to specific hardware constraints (e.g., FPGAs) and emerging low-precision formats.
Scalable Benchmarking Infrastructure: The authors developed a mixed-precision benchmarking tool designed for large-scale deployment. This includes a suite of simulated benchmarks for numerical algorithms and a parallel execution framework that reduces the runtime of precision tuning experiments by approximately 3.4× (from ~13 hours to ~3 hours in their tests) through process-level parallelism.
Comprehensive Empirical Validation: The approach is validated on a suite of numerical programs, including linear solvers (dense and sparse LU factorization) and applications from the Rodinia benchmark suite (Back Propagation, HotSpot, Particle Filter, SRAD).

Results
The experiments evaluated two precision combinations: (I) E5M2-FP16-FP32-FP64 and (II) E5M2-BF16-FP32-FP64, across varying accuracy requirements (1 to 10 correct digits).

Precision Reduction: The results demonstrate that a substantial proportion of variables can be safely reduced to lower precision. On average, 43% of variables can be represented with 32-bit precision or less, and 28% can be reduced to 16-bit precision or lower.
Over-provisioning of FP64: The study confirms that standard double precision is often over-provisioned for many scientific computing tasks.
Custom Format Utility: Customized formats like E5M2 were found to be viable for a significant portion of variables (averaging 23% of variables in the configurations), with E4M3 showing similar proportions.
Algorithm-Specific Sensitivity: The analysis revealed that precision requirements vary by algorithmic component. For instance, in Back Propagation, the sigmoid activation path required higher precision to stabilize exponential evaluations, while in LU factorization, pivoting operations could often tolerate 8-bit formats.

Significance and Claims
The paper claims that automated precision tuning, when extended to support customized formats, can derive efficient mixed-precision configurations tailored to application-specific accuracy requirements. The authors position this work as a guide for the scientific community, demonstrating that significant performance and resource gains are achievable without manual intervention. The integration of FloatX and the parallel benchmarking framework addresses the dual challenges of format flexibility and search scalability. The authors modestly note that while the current work focuses on direct linear solvers and specific kernels, future work will address iterative solvers and the integration of mixed-precision numerical kernels (e.g., for Krylov methods) into the tuning process. The tool and benchmarks are made available to the community to facilitate further research in this domain.