HPCG
HPCG measures supercomputer performance on memory-bound sparse conjugate-gradient computations, complementing LINPACK's dense HPL. Its low fraction-of-peak results reveal how memory and interconnect limit real HPC applications.
HPCG (High Performance Conjugate Gradients) is a supercomputer benchmark created as a complement to LINPACK's HPL. Where HPL measures dense matrix performance and tends to flatter peak floating-point capability, HPCG stresses the memory subsystem, irregular access patterns, and communication that limit real scientific applications. It produces a companion ranking to the TOP500 list.
HPCG implements a preconditioned conjugate gradient solver on a sparse linear system arising from a 3D partial differential equation. The computational kernels — sparse matrix-vector multiply, vector updates, dot products, and a multigrid preconditioner — are dominated by memory access and fine-grained communication, exactly the patterns that dominate production HPC codes.
What It Measures
HPCG reports performance in GFLOP/s (or PFLOP/s at scale), but the meaningful comparison is the fraction of a machine's theoretical peak it achieves. Real systems typically reach only 1–5% of peak on HPCG versus 60–90% on HPL, which is the point: the gap reveals how memory bandwidth, latency, and interconnect — not raw FLOPs — govern application performance.
Methodology
The benchmark runs across all nodes using MPI plus on-node parallelism, solving the sparse system to a fixed iteration count over a problem sized to fill available memory. It includes a built-in validation and a required minimum run time to ensure results reflect steady state. Submitters report GFLOP/s along with full system configuration, and results are curated alongside the TOP500.
How to Interpret Results
Compare HPCG GFLOP/s for absolute capability and the HPCG-to-HPL ratio for architectural balance. A system high on TOP500 but low on the HPCG list has FLOPs that real codes cannot use well — a warning for memory-bound workloads. Strong HPCG results indicate good memory bandwidth and a low-latency interconnect. Use it to predict performance of PDE solvers, CFD, and other sparse, communication-heavy applications.
Limitations
HPCG models one class of algorithm — sparse iterative solvers — and is not representative of dense, FFT-heavy, or AI workloads. Like all single-number benchmarks, it can be over-optimized for the ranking. It does not capture I/O, fault tolerance, or full-application complexity, and its low fraction-of-peak figures, while informative, can be misread as poor hardware rather than as a realistic measure of usable performance.