HPL-AI / HPL-MxP

HPL-AI, now known as HPL-MxP, is a mixed-precision variant of the classic High Performance LINPACK benchmark. It was created because modern accelerators deliver far higher throughput in low-precision formats (FP16, BF16, FP8) used for AI than in the FP64 double precision that traditional HPL measures. HPL-MxP captures this AI-era capability while still producing a verifiably accurate result.

The benchmark solves the same dense linear system as HPL but performs the heavy factorization in lower precision, then uses iterative refinement to recover a solution as accurate as a full double-precision solve. This mirrors a common HPC and AI technique: compute fast in low precision, correct cheaply to high precision.

What It Measures

HPL-MxP reports effective mixed-precision FLOP/s, often several times higher than the same machine's HPL FP64 result. The key derived figure is the speedup over HPL, which quantifies how much usable performance the low-precision pipelines unlock. It produces a companion ranking to the TOP500, highlighting machines built for AI and mixed-precision science.

Methodology

The benchmark factors the matrix in reduced precision across the full system using MPI and accelerators, then applies iterative refinement (typically GMRES-based) until the residual matches a double-precision-quality threshold. Because accuracy is verified, results cannot be inflated by simply dropping precision without correction. Submitters report the achieved mixed-precision rate and full configuration.

How to Interpret Results

Compare HPL-MxP FLOP/s for low-precision capability and the HPL-MxP-to-HPL ratio to see how much the architecture favors AI-style arithmetic. A large ratio indicates abundant low-precision throughput relative to FP64 — characteristic of GPU-dense systems. Use it to estimate suitability for AI training and for scientific codes that can exploit iterative refinement, but read it alongside HPL and HPCG for a balanced view.

Limitations

HPL-MxP still measures a dense linear solve, so like HPL it can overstate real-application performance and underweights memory-bound behavior. The achievable speedup depends on whether a given algorithm tolerates low precision plus refinement; many codes do not. Results are sensitive to accelerator-specific tuning, and the benchmark does not capture full AI training pipelines, data movement, or model convergence, which determine real machine-learning throughput.