NVIDIA CCCL 3.1 Adds Floating-Point Determinism Controls for GPU Computing

Caroline Bishop Mar 05, 2026 17:46

NVIDIA's CCCL 3.1 introduces three determinism levels for parallel reductions, letting developers trade performance for reproducibility in GPU computations.

NVIDIA has rolled out determinism controls in CUDA Core Compute Libraries (CCCL) 3.1, addressing a persistent headache in parallel GPU computing: getting identical results from floating-point operations across multiple runs and different hardware.

The update introduces three configurable determinism levels through CUB's new single-phase API, giving developers explicit control over the reproducibility-versus-performance tradeoff that's plagued GPU applications for years.

Why Floating-Point Determinism Matters

Here's the problem: floating-point addition isn't strictly associative. Due to rounding at finite precision, (a + b) + c doesn't always equal a + (b + c). When parallel threads combine values in unpredictable orders, you get slightly different results each run. For many applications—financial modeling, scientific simulations, blockchain computations, machine learning training—this inconsistency creates real problems.

The new API lets developers specify exactly how much reproducibility they need through three modes:

Not-guaranteed determinism prioritizes raw speed. It uses atomic operations that execute in whatever order threads happen to run, completing reductions in a single kernel launch. Results may vary slightly between runs, but for applications where approximate answers suffice, the performance gains are substantial—particularly on smaller input arrays where kernel launch overhead dominates.

Run-to-run determinism (the default) guarantees identical outputs when using the same input, kernel configuration, and GPU. NVIDIA achieves this by structuring reductions as fixed hierarchical trees rather than relying on atomics. Elements combine within threads first, then across warps via shuffle instructions, then across blocks using shared memory, with a second kernel aggregating final results.

GPU-to-GPU determinism provides the strictest reproducibility, ensuring identical results across different NVIDIA GPUs. The implementation uses a Reproducible Floating-point Accumulator (RFA) that groups input values into fixed exponent ranges—defaulting to three bins—to counter non-associativity issues that arise when adding numbers with different magnitudes.

Performance Trade-offs

NVIDIA's benchmarks on H200 GPUs quantify the cost of reproducibility. GPU-to-GPU determinism increases execution time by 20% to 30% for large problem sizes compared to the relaxed mode. Run-to-run determinism sits between the two extremes.

The three-bin RFA configuration offers what NVIDIA calls an "optimal default" balancing accuracy and speed. More bins improve numerical precision but add intermediate summations that slow execution.

Implementation Details

Developers access the new controls through cuda::execution::require(), which constructs an execution environment object passed to reduction functions. The syntax is straightforward—set determinism to not_guaranteed, run_to_run, or gpu_to_gpu depending on requirements.

The feature only works with CUB's single-phase API; the older two-phase API doesn't accept execution environments.

Broader Implications

Cross-platform floating-point reproducibility has been a known challenge in high-performance computing and blockchain applications, where different compilers, optimization flags, and hardware architectures can produce divergent results from mathematically identical operations. NVIDIA's approach of explicitly exposing determinism as a configurable parameter rather than hiding implementation details represents a pragmatic solution.

The company plans to extend determinism controls beyond reductions to additional parallel primitives. Developers can track progress and request specific algorithms through NVIDIA's GitHub repository, where an open issue tracks the expanded determinism roadmap.

• nvidia
• gpu computing
• cccl
• floating-point determinism
• cuda