NVIDIA Says FP64 Emulation Lifts Rubin Matrix Math to 175 TFLOPS; Vector Code Sees No Gain
18 hour ago / Read about 21 minute
Source:TechTimes

Mariia Shalabaieva/Unsplash

NVIDIA's cuBLAS library can now run double-precision (FP64) matrix multiplication on integer Tensor Cores, and the company's own tests show up to 5.5x native throughput on Vera Rubin NVL72 systems. The gain applies only to matrix multiplication, not to the vector math that dominates many simulation codes, and every speedup figure so far comes from NVIDIA's own benchmarks. Anyone buying GPUs for scientific computing should read the caveats below before treating 5.5x as a general speedup.

Rubin Emulation Peaks at 175 TFLOPS in NVIDIA Tests Against 33 TFLOPS Native

NVIDIA reports that Ozaki-II reaches about 175 TFLOPS on Vera Rubin NVL72, a 5.5x gain over native FP64 on that platform. On GB200 Blackwell hardware the company reports up to 3.9x (about 147 TFLOPS). On RTX PRO 6000 Blackwell Server Edition it reports gains of roughly 10x to 23x (about 37 TFLOPS) depending on matrix shape. Those multiples depend on the baseline; the same NVIDIA post measures some application results against native FP64 on an older A100 GPU rather than on Rubin itself.

Rubin's native FP64 rating is about 33 TFLOPS per GPU, one teraFLOP below the four-year-old H100's 34 TFLOPS and below Blackwell's B200. Jack Dongarra of the University of Tennessee said at the SC25 conference that Nvidia's floating-point capability had not improved from Hopper to Blackwell. Emulation is how NVIDIA makes up that gap in software.

How Integer Tensor Cores Rebuild FP64 Results: Ozaki-II and the 2M Method

The technique is the Ozaki scheme, which splits FP64 numbers into integer pieces, multiplies the pieces on low-precision hardware, and recombines the results. The first version, Ozaki-I, slices each matrix into 8-bit integer parts, so the number of matrix multiplications grows with the square of the slice count.

Ozaki-II replaces slicing with the Chinese Remainder Theorem. Each matrix is reduced modulo several pairwise-coprime integers, one integer multiplication runs per modulus, and the theorem reassembles the full-precision result, so cost grows roughly linearly with the number of moduli. One set of published ISC 2026 slides states that 15 moduli match the accuracy of 7 Ozaki-I slices, and relays a secondhand report that NVIDIA found no applications needing more than 7 slices. The trade is the same accuracy with far fewer integer multiplications.

For complex-number multiplication (ZGEMM), cuBLAS uses the 2M algorithm, which does two real multiplications instead of four. On Rubin, the CUDA 13.4.1 release notes describe a new 12-bit integer type called TI16, issued through the tcgen05.mma instruction on compute capability 10.7.

Does Emulated FP64 Give the Same Answers as Native Hardware?

NVIDIA says the emulation preserves FP64 accuracy. Dan Ernst of NVIDIA defended the approach to The Register, acknowledging that emulation is not IEEE-compliant while arguing the difference matters only for some applications. The library's Automatic Dynamic Precision feature estimates how many slices an input needs, adds under 10% overhead, and falls back to native FP64 when emulation is not safe. An independent paper on grading BLAS accuracy tested cuBLAS on a Blackwell B200 with CUDA 13.3 and reported that the library defaulted to native FP64 on a wide-range test input and still earned an "A" grade. That paper covered Blackwell, not Rubin, and no independent grading of the new Rubin path has been published that this review could find.

Other researchers urge caution. An error analysis of Ozaki-II finds that wide exponent distributions degrade accuracy in some modes. Dan Stanzione, executive director of the Texas Advanced Computing Center, said the center will compare native FP64 against Ozaki results for all acceptance applications on its Horizon system, and will submit High Performance LINPACK results in both modes.

AMD and NVIDIA Disagree on Whether Emulation Can Replace Native FP64

AMD, which sells GPUs with large native FP64 throughput, argues the opposite case. Its researcher Nicholas Malaya told The Register that FP64 emulation works best for well-conditioned systems such as the High Performance LINPACK benchmark, and that Ozaki emulation uses about twice the memory for FP64 matrices. AMD's upcoming Instinct MI430X instead leans on native hardware, with 288 TFLOPS of FP64 according to TechTimes reporting on the LUMI-AI deal.

AMD has a commercial stake in native FP64, just as NVIDIA has one in emulation. NVIDIA's counterargument, as reported by HPCwire, is that more native FP64 would not speed up real applications that are bottlenecked by registers, caches, and HBM memory rather than raw compute.

Read more: Europe Signs $451M AMD Deal for LUMI-AI, Defying NVIDIA AI Factory Dominance

Vector Workloads and Small Matrices Get No Emulation Boost

Emulation accelerates only general matrix multiplication (GEMM), the routines such as DGEMM and ZGEMM. Codes dominated by vector operations, such as many computational fluid dynamics solvers, see no speedup from it. NVIDIA notes that when problems are too small to benefit, cuBLAS heuristics choose native FP64 so emulation carries no penalty.

Small matrices also gain little. The ISC 2026 slides note that Ozaki-I is often faster at small sizes because Ozaki-II's overhead is not amortized, that workspace grows with problem size, and that native FP64 may remain preferable for reliable, verified numerical computing. Malaya also said that fewer than 10% of real-world applications have made the changes needed to benefit from Ozaki.

Quantum Chemistry and Materials Codes Show the Gains NVIDIA Reports

NVIDIA cites two application tests: coupled-cluster (CCSD) quantum chemistry through its cuEST library on S22 molecular complexes, and the Epsilon module of BerkeleyGW, a many-body materials code. In the materials test, the company reports ZGEMM speedups of 6.6x on Rubin NVL72 and 3.9x on GB200. Its post gives differing baselines for the chemistry results, so those multipliers should be read against the baseline NVIDIA names for each.

Independent work on a density functional theory code found that low-precision settings failed to converge in a self-consistent-field loop, while the higher-precision settings tested matched the FP64 baseline. That test ran on a GB200 node, not Rubin.

Read more: NVIDIA Vera Rubin Supercomputer: One Rack, TOP500 Power, 35 European Labs Now Deploying

Emulation Ships in CUDA Toolkit 13.4, With Native Fallback Built In

The Ozaki-II and Rubin support are documented in the CUDA Toolkit 13.4 line. Rubin support there is a developer preview, and NVIDIA's CUDA 13.5 release brings Rubin general availability support. NVIDIA's blog and release notes cite different toolkit point versions and different Rubin DGEMM peaks, 175 TFLOPS in the blog against a higher figure in the notes, so check the release notes for the build you install. Teams planning purchases should run their own accuracy and speed tests on their own matrices, because the published multipliers come from NVIDIA's chosen problem sizes.

Bottom line: emulation delivers real, vendor-measured gains for large matrix multiplications on Rubin, but it does not help vector-heavy codes or small matrices, independent accuracy testing on Rubin is still missing, and Rubin's native FP64 has not improved.

Frequently Asked Questions

Is emulated FP64 as accurate as native FP64?

NVIDIA says it matches FP64 accuracy and falls back to native hardware when emulation is unsafe. An independent grading paper observed that fallback behavior on Blackwell, but Rubin has not been independently graded.

Will emulation speed up every scientific code on Rubin?

No. It accelerates matrix multiplication routines only, and small matrices and vector-heavy codes gain little.

What is the Ozaki scheme?

It is a method that splits FP64 numbers into pieces that fit integer hardware, multiplies the pieces exactly, and recombines the results. Ozaki-II uses the Chinese Remainder Theorem to do this with fewer multiplications.

Why does emulation matter if Rubin's native FP64 is flat?

Integer Tensor Cores have grown much faster than FP64 units, so emulation is NVIDIA's main route to higher double-precision matrix throughput on Rubin, which is why Dongarra flagged the stagnant native rating.