Questions have been swirling around with more velocity lately about the viability of high performance Linpack (HPL) as a representative measure for assessing true HPC application performance. As new architectures and different data access patterns infiltrate a growing army of HPC applications, consensus is building that new metrics are needed to keep pace.
At the same time, over its 20-year history. Linpack has become a well-respected and understood benchmark that carries significant weight within and outside of HPC circles. Even if there is disagreement about the validity of the results against real life use, there is no doubt that the metric has brought significant outside attention to HPC–and some standard to compare historical and current systems.
But with great benchmarks come great manipulations. Systems that strive to top the Top 500 list based on this rating method end up making some either/or decisions about architecture versus tailoring systems to meet application demands.
Unlike many of today’s HPL chart-toppers, the early HPL results served up a solid ranking that matched the actual performance (versus having wide disparity between peak and sustained figures). For these and other reasons, HPL as the primary benchmark has been called into question–both by the Top 500 team and by user sites, including NCSA, which made a decision to focus on real application performance over meeting Linpack targets.
Dr. Jack Dongarra, one of the founders of the Top 500, has been vocal about the need to rethink the trusty benchmark. Along with Sandia National Lab’s Michael Heroux, he presented a new concept for ranking systems called the high performance conjugate gradient (HPCG) benchmark, which was spelled out during the International Supercomputing Conference today in Leipzig, Germany.
While Dongarra doesn’t think it would be useful to entirely eliminate HPL as a metric, in part because of its reach and recognition, he believes it should be used as an alternative way to rank systems in much the same way as the Green 500 shuffles items on the list according to its own benchmark.
The goal of the new metric would be to represent computation and data access patterns that are found in many common applications. The goal, they say is to “strive for a better correlation to real scientific application performance…and drive computer system design and implementation in directions that will better impact performance improvement.”
This is an important issue to address since each iteration of the Top 500 will show increasing gaps between real versus theoretical performance–and applications are moving much closer to differential equations bases, which HPL doesn’t address. Just as it did in the 1990s, HPL solves on linear lines that favors floating point and memory systems–which are not valid for an expanding set of HPC applications.
Coupled with that, the rise in accelerators and coprocessors (more on that in the context of the Top 500 here) isn’t expected to halt soon–meaning these flaws will become far more pronounced. For instance, as Dongarra and Heroux point out using Titan (18.688 nodes with 16-core, 32 GB AMD Opterons and a 6GB K20 GPU):
“Titan was the top-ranked system in November,, 2012 using HPL. However, in obtaining the HPL result on Titan, the Opteron processors played only a supporting role in the result. All floating point computation and all data were resident on the GPUs. In contrast, real applications, when initially ported to Titan will typically run solely on the CPUs and selectively offload computation to the GPU for acceleration.”
With this in mind, they say that their new metric has to be able address examples like this by driving improvements in systems to benefit applications–thereby assigning a metric that can be optimized for a specific platform, but offer the end result of creating better real application performance and reliability.
The proposed HPCG benchmark, detailed in this primer beginning on page 11, will “consider the preconditioned conjugate gradient (PCG) method with a local symmetric Gauss-Seidel preconditioner.” Again, see the primer for more detailed information. The reference code will be implemented in C++ using MPI and OpenMP.
Dongarra and Heroux argue that through this method, they will be able to address what HPL can’t. For instance, they can cover most of the main communication and computational methods; allow for a score that can represent benefits from boosting local memory system performance and can go far beyond floating point math.
The two researchers note that they expect that the new benchmark will adapt to take into account emerging trends as they happen but “the relevance of HPL as a proxy for real application performance has become very low and we must seek and alternative.”
Dongarra told us today that we can expect a release at SC13–just in time for the next round of rankings.