July 27, 2007

Compilers and More: Productivity and Compilers

Michael Wolfe

The mantra of productivity is beginning to permeate the HPC community. But can we usefully define it? And, once defined, are there straightforward ways to improve it? PGI's Michael Wolfe examines some approaches to the productivity dilemma.

Productivity is the new buzzword, and HPC now stands for High Productivity Computing; even HPCwire has adopted this moniker. Can we usefully define productivity? Several metrics have been proposed, most being difficult or impossible to use in any scientific way. The performance metric is typically results per time unit, like flops per second, or runs per day. A productivity metric has a different denominator, usually convertible into dollars (or other currency), such as programmer hours, total system cost, or total power usage.

For example, a simple (and useless) metric, let’s call it M1, is to measure the speedup gained for an application relative to the cost of attaining that speedup. Speedup is measured relative to some base time, and cost can be measured in dollars or hours (for programmer time). If we fix the target system, the hardware cost is constant; software development cost is sometimes normalized across different programmers by counting source lines of code (SLOC), which is coarse but defensible. Using SLOC favors higher level languages, which have shorter programs, though the performance may suffer. The metric M1 is defined as M1=Sp/SLOC where Sp is the speedup, and SLOC is the program length, estimating the programming effort. One study used this metric and indeed found that sequential MATLAB competes well with parallel C or Fortran; because the MATLAB program is shorter, the productivity metric is high, even though the absolute performance does not measure up to a parallel implementation. On the other hand, high-level parallel array languages like ZPL (http://www.cs.washington.edu/research/zpl) benefit both from low SLOC and high performance, and really shine using this metric.

One problem with M1 as a metric is that it implicitly assumes that you will run your program only once. If you run your program many times, it may be worthwhile to invest a great deal of additional effort for a comparatively small speedup; metric M1 will not show this to be beneficial, but the total time savings may change your mind.

Another problem with M1 is that it can show improved productivity even if the performance decreases. While it is true that most of our standard computing needs are not particularly sensitive to performance (think email), this is not the segment that HPC is intended to address. (If it is, someone let me know. I want out!) Even in the high performance world, we might be willing to accept small performance decreases if the development time and cost are significantly lower. However, rating a slow program as highly productive is counterproductive (pun intended).

Beyond Performance

Yet another problem with M1 is that it ignores additional considerations, such as debugging, portability, performance tuning, and longevity. These all fit into the productivity spectrum somewhere. Let’s discuss each briefly.

Debugging includes finding any programming errors as well as finding algorithmic problems. Interactive debuggers are common, but as we inexorably move into the world of parallel programming, these will have to scale to many simultaneously active threads. Right now the only commonly available scalable parallel debugger is Totalview, which sets the standard. Mature systems with available, supported debuggers are often preferable to a newer system where debugging is limited to print statements.

Portability concerns limit innovation. If we need portability across systems, we are unlikely to adopt or even experiment with a new programming language or library — unless or until it is widely available. Standard Fortran and C address the portability problems quite nicely, and C++ is also relatively portable. A common base library, such as MPI, however difficult to use, is at least widely available, and if necessary, we could port it ourselves.

Another aspect of portability is performance. When we restructure a program for high performance on one machine, we hope and expect the performance improves on other platforms. Programmers who worked on the vector machines in years past found that the effort to restructure their code for one vector machine did, in fact, deliver the corresponding high performance on other vector machines; the machine model was stable and easy to understand. MPI-based programs benefit from this; a parallel MPI program will run more or less as well in parallel on any reasonable MPI implementation.

Longevity concerns also limit innovation. We might be willing to adopt a new programming language, such as Unified Parallel C, for a current research project, but we are unlikely to use it for a product that we expect to live for a decade or more. Regardless of one’s feelings about UPC as a language, we are typically concerned that we will write a program today for which there will be no working compilers or support in ten years. I had the same problems with Java in its early years; programs that I built and used for months would suddenly stop building or working when we upgraded our Java installation.

Improving Productivity

We know what we really mean by high productivity, though it’s hard to quantify: we want to get high performance, but spend less to get it. Usually we mean spending less time in application development. If we go back 50 years, productivity is exactly what the original Fortran developers had in mind: delivering the same performance as machine language, with the lower program development cost of a higher level language. We would do well to be as successful as Fortran. There are no magic bullets here; someone has to do the work. There are four methods to improving productivity.

The first, and the one we’ve depended upon until now for improved performance (and hence productivity), is better hardware; faster processors improve performance. Hardware extraction of parallelism has long been promised (as has software parallelism extraction) and has been quite successful at the microarchitectural level (e.g., pipelined superscalar processors). But the gravy train here has slowed to a crawl. Hardware benefits are going to come with increased on-chip parallelism, not improved speed, and large scale multiprocessor parallelism is still the domain of the programmer.

The second (quite successful) method is faster algorithms. Sparse matrix solvers can be an order of magnitude more efficient than dense solvers when they apply, for instance. No hardware or software mechanism can correct an inappropriate or slow algorithm. Algorithm improvements are often portable across machine architectures and can be recoded in multiple languages, so the benefits are long-lived. So while new algorithm development is quite expensive, it can pay off handsomely.

The third method, often proposed and reinvented, is to use a high performance library for kernel operations. One such early library was STACKLIB, used on the Control Data 6600 and 7600 (ten points if you remember the etymology of the name). This library morphed over time into the BLAS, and now we have LINPACK and LAPACK. The hope is the vendor (or other highly motivated programmer) will optimize the library for each of your target architectures. If there are enough library users, the library author may have enough motivation to eke out the last drop of performance, and your productivity (and performance) increases. In the parallel computing domain, we have had SCALAPACK, and now we have RapidMind and (until recently) PeakStream. In these last two, the product is more than a library, it’s a mechanism for dynamic (run-time) code generation and optimization, something that was just recently an active field of research.

The upside of using a library is that when it works — when the library exists and is optimized on all your platforms — you preserve your programming investment and get high performance. One downside is that you now depend on the library vendor for your performance. At least with open source libraries you can tune the performance yourself if you have to, but then your productivity rating drops.

More importantly, the library interface becomes the vocabulary of a small language embedded in the source language. Your program is written in C or Fortran, but the computation kernel is written in the language of whatever library you use. When you restrict your program to that language, you get the performance you want. If you want to express something that isn’t available in that language, you have to recast it in that language, or work through the performance problems on your own. With the latest incarnations of object-oriented languages, the library interface looks more integrated with the language, complete with error-checking; but you still miss the performance indicators that vector compilers used to give (see below).

The fourth method is to use a better programming language; or, given a language, to use a better compiler. New languages are easy to propose, and we’ve all seen many of them over the decades; serious contenders are less common. Acceptance of a new language requires confidence in its performance, portability, and longevity. We often use High Performance Fortran as an example. It had limited applicability, but had some promise within its intended domain. It had portability, if only because major government contracts required an HPF compiler. However, when immature implementations did not deliver the expected performance, programmers quickly looked in other directions. Perhaps it could have been more successful with less initial hype, allowing more mature implementations and more general programming models to develop. We now see new parallel languages on the horizon, including the parallel CoArray extensions to Fortran (currently on the list for addition to Fortran 2008), Unified Parallel C, and the HPCS language proposals. Let’s see if they can avoid the pitfalls of HPF.

Compilers (or programming environments) also affect productivity. Early C compilers required users to identify variables that should be allocated to registers and encouraged pointer arithmetic instead of array references. Modern compilers can deliver the same performance without requiring programmers to think about these low-level details. Compilers that identify incorrect or questionable programming practice certainly improve productivity, but in the high performance world we should demand more. Vectorizing compilers in the 1970s and 1980s would give feedback about which inner loops would run in vector mode and which would not. Moreover, they were quite specific about what prevented vectorization, even down to identifying which variable in which subscript of which array reference in which statement caused the problem. This specificity had two effects: it would encourage the programmer to rewrite the offending loop, if it was important; and it trained the programmer how to write high performance code. Moreover, code that vectorized on one machine would likely vectorize on another, so the performance improvements were portable as well.

Learning from the vector compiler experience, we should demand that compilers and programming tools give useful, practical performance feedback. Unfortunately, while vectorization analysis is local to a loop and easy to explain, parallel communication analysis is global and can require interprocedural information.

One HPF pitfall that the HPCS languages must avoid is the ease with which one can write a slow program. In HPF, a single array assignment might be very efficient or very slow, and there’s no indication in the statement which is the case. A programmer must use detailed analysis of the array distributions and a knowledge of the compiler optimizations to determine this. MPI programs, as hard to understand as they may be, at least make the communication explicit. The HPCS language proposals to date have some of the same characteristics as HPF, and implementations will need to give performance hints to ensure that users can get the promised performance/productivity.

The key to a useful productivity metric is the ability to measure that we are improving the productivity of generating high performance programs. We may measure productivity as performance/cost, but we don’t get true high productivity by simply reducing the denominator faster than we reduce the numerator. We should want to reduce the denominator, the cost, while preserving or even increasing the performance.


Michael Wolfe has developed compilers for over 30 years in both academia and industry, and is now a senior compiler engineer at The Portland Group, Inc. (www.pgroup.com), a wholly-owned subsidiary of STMicroelectronics, Inc. The opinions stated here are those of the author, and do not represent opinions of The Portland Group, Inc. or STMicroelectronics, Inc.

Share This