Programming in the era of parallelism
With the coming of age of multiprocessors, program performance and efficiency has become more important and difficult to achieve. Furthermore, the applications of today must also be scalable so that they can make effective use of the additional parallelism introduced by newer generations of machines. To achieve strong and scalable performance, programmers must do all the work traditionally required for sequential tuning and in addition address the complex optimization issues introduced by parallelism. This difficulty is likely to increase even further if, as it is expected, multicores become heterogeneous or their overall organization changes significanly over time. However, even assuming homogeneous and stable organizations, programmer productivity is bound to suffer due to the initial cost of tuning for multiprocessors and the need for adaptation as the number of processors increase.
In this talk, I will discuss future directions for programming language design, compiler technology, and the emerging autotuning strategies in the context of parallel programming. I will argue that advances in languages, compilers, and autotuning techniques will be necessary to recover the ground in productivity that has been lost with the advent of multicores. I will also argue that these tree components of a programming environment must be designed jointly to facilitate program tuning. The ultimate goal is for tuning to be accomplished without requiring the programmer to be concerned with the details of the target machine. It is expected that languages, compilers and autotuning techniques will evolve into a methodology that will dramatically reduce and perhaps eliminate in some cases the cost of porting programs across machine generations and machine classes. The availability of such methodology should not only help programmer productivity but also give machine designers more freedom to innovate.