December 13, 2011

Ten Ways to Fool the Masses When Giving Performance Results on GPUs

Scott Pakin

The performance potential of GPU computing has produced significant excitement in the HPC community. However, as was the case with the advent of parallel computing decades ago, the nascent technology does not equally benefit all applications — or even all components of a single application. Alas, modest speedups from GPU acceleration are rarely publication-worthy, a fact that occasionally leads GPU zealots to adopt scientifically dubious techniques to artificially inflate the performance benefit of GPU computing to more impressive levels.

In this modern revival of David Bailey’s classic report, “Twelve Ways to Fool the Masses When Giving Performance Results on Parallel Computers,” I present ten forms of experimental sloppiness I’ve encountered repeatedly in scientific publications, all of which can be used to chicane GPU rookies (and pointy-haired bosses) into believing that GPUs can magically improve any application’s performance by multiple orders of magnitude. With this list as their vade mecum, readers will learn to be skeptical of exaggerated GPU performance claims.

Ready to boost your reported GPU performance results without boosting your actual GPU performance? Read on…

1. Quote performance results only with 32-bit floating-point arithmetic, not 64-bit arithmetic.

GPUs get double the performance when using single-precision arithmetic. Who needs more than eight decimal digits of precision, anyway? It goes without saying that the CPU version of the code you compare against should use exclusively 64-bit arithmetic because, well, that’s how people write CPU code (even though CPUs also double their flop rate when utilizing 32-bit SIMD arithmetic).

2. Don’t time data movement or kernel-invocation overhead.

Copying data between CPU memory and GPU memory is slow and cuts into the amount of GPU performance that one can claim. Hence, to make GPUs look good, be sure to start the clock after all of the program’s data have already been transferred to GPU memory and the kernel has already been launched and stop the clock before the results are copied back to CPU memory. There are two corollaries to this rule:

Corollary 1: Never, ever report the performance of an application running across more than one GPU-accelerated node. Doing so requires all sorts of CPU-managed communication, and *that* requires data movement and additional kernel invocations — bad for speedup numbers.

Corollary 2: Always report performance of single kernels, not of complete applications. This is especially true of applications containing important but hard-to-accelerate subroutines.

3. Quote GPU cost and ubiquity for low-end parts. Measure performance on high-end parts.

Here’s some text you can adapt as necessary: “GPUs are an important platform to target because they cost under $100 and come standard with all modern computer systems. For our experiments we measured performance on an NVIDIA Tesla M2090…”

4. Quote memory bandwidth only to/from on-board GPU memory, not to/from main memory.

Impress your audience with your high-end GPU’s ability to do memory transfers at 177 GB/s. As long as you never need to store, transfer, or utilize the result of your computations, that’s a perfectly honest number to quote.

5. Disable ECC checks on memory.

GPUs run faster — and provide more usable memory capacity — when they don’t have to try so hard to produce correct data. Besides, what GPU kernel runs long enough that this should be an issue?

6. Compare full (or even multiple) GPU performance to a single CPU core.

Always compare what you started with (a sequential CPU program) with what you ended up producing (a parallel GPU program). A 10x speedup of GPU code over CPU code sure seems a lot more impressive when you neglect to mention that your host system contains two sockets of eight-core CPUs, which you *could* have used instead.

7. Compare heavily optimized GPU code to unoptimized CPU code.

Naturally, you’ve made sure the GPU code runs as fast as possible by restructuring it to exploit data parallelism, memory locality, and other GPU-friendly program characteristics. Now be sure to compare it only against the original, naive CPU code, not a version that exploits the CPU’s SIMD instructions, properly blocks for cache, optimally aligns data structures, or includes any of the other performance optimizations that CPU programmers rarely bother with. Definitely don’t backport your GPU modifications to the CPU, or the reported speedup will be disappointingly less.

8. Scale the problem size to fit within GPU memory.

This recommendation goes both ways. If your GPU has 6 GB of on-board memory and your application’s problem size is larger than that, then scale it down to 6 GB so you can avoid all the expensive synchronization and messy double-buffering that large problem sizes entail. If your GPU has 6 GB of on-board memory and your application’s problem size is significantly smaller than that, then weak-scale the problem size, even beyond meaningful bounds, so you can reap the performance benefits of increased data parallelism. The following recommendation further develops this point:

9. Sacrifice meaningful numerics for GPU performance.

GPUs are renowned for their computational throughput. However, reaching peak performance requires amortizing that nasty startup cost of moving kernels and data to the GPU. Hence, to demonstrate good GPU performance, always run far more iterations than are typical, necessary, practical, or even meaningful for real-world usage, numerics be damned!

10. Select algorithms that favor GPUs.

The best CPU algorithms often don’t make the best GPU algorithms and vice versa. Consequently, you should always take whatever algorithm works best on the GPU and benchmark that against a CPU version. What’s great about this approach over comparing the performance of the best CPU algorithm to that of the best GPU algorithm is that it leads to a “fair” comparison. After all, you ran the same algorithm on both systems — fair, right?

Parting thoughts

The good news is that advances in GPU technology are alleviating some of the costs that the preceding trickery attempts to hide. While parts of my list may soon appear anachronistic, there should still be enough deviousness remaining to please even the most discerning GPU fanboy.

As a final, largely unrelated comment, can we please eliminate the oxymoronic noun “GPGPU” from our collective lexicon? If a processor is specialized for graphics processing, then it’s not really a general-purpose device, is it?

Further reading

[Bai91] David H. Bailey. “Highly parallel perspective: Twelve ways to fool the masses when giving performance results on parallel computers”. Supercomputing Review, 4(8):54-55, August, 1991. ISSN: 1048-6836. Also appears as NASA Ames RNR Technical Report RNR-91-020.

[BBR10] Rajesh Bordawekar, Uday Bondhugula, and Ravi Rao. “Can CPUs match GPUs on performance with productivity?: Experiences with optimizing a FLOP-intensive application on CPUs and GPU”. IBM T. J. Watson Research Center Technical Report RC25033 (W1008-020). August 5, 2010.

[LKC+10] Victor W. Lee, Changkyu Kim, Jatin Chhugani, Michael Deisher, Daehyun Kim, Anthony D. Nguyen, Nadathur Satish, Mikhail Smelyanskiy, Srinivas Chennupaty, Per Hammarlund, Ronak Singhal, and Pradeep Dubey. “Debunking the 100X GPU vs. CPU myth: An evaluation of throughput computing on CPU and GPU”, Proceedings of the 37th Annual International Symposium on Computer Architecture (ISCA 2010), Saint-Malo, France, June 19-23, 2010. ISBN: 978-1-4503-0053-7, DOI: 10.1145/1815961.1816021.

Share This