The best software is yet to come?
Peter Dzwig, Concertant
One of the highlights of the show for me was Wednesday's invited talk By David Patterson of Berkeley. To a lot of people his paper (written with a huge amount of asistance from a raft of colleagues) “The Landscape of Parallelism: The view from Berkeley” (see: http://www.eecs.berkeley.edu/Pubs/TechRpts/2006/EECS-2006-183.html) is a modern classic, whether or not you agree wih its point of view and some don't.
Consequently his views on the state of the software world as it will be in the future was not without significance. If the industry doesn't face up to the change in hardware achitecture that is coming, it is about to hit a major barrier. He strongly believes that there is no individual killer app, nor killer micro to rescue the industry – which is what stymied the last parallelism revolution. The technology just isn't going to be there. The whole industry needs to address the problem and to be more receptive to new ideas. However little evidence has been seen this week of the preparation of strategies by the industry.
Patterson sees that the biggest problem is for the hardware industry. It can move fast to produce new processors, but the software industry seems unable to keep up with it. The lack of software will slow the growth in the market, and we will have to drop below the Moore's Law curve. That will have dramatic consequences for the industry. There really is a pressing need for the software industry to get its act together and address the issues that multicore will bring.
Patterson's goal and that of his group is to produce software targeted at 100 cores and which will meet the scaling every 2 years that would be in line with a Moore's Law-like growth of the number of cores per procesor. That works fine for a longer term strategy but for core counts in the low tens it changes little for the industry's present issues. He claims no preconceived big idea. Their strategy – and the one set out in “The View from Berkeley” is to start with applications, not let it purely be driven by software architect’s dreams. Their approach is to examine the structures underlying the software and try to understand what would be needed to make the applications most likely to be used tomorrow work well, and make them capable of migrating to higher core counts (above 100).Patterson reckons that the applications of tomorrow that will breakthrough and really take advantage of what will be on offer in a few years will be new ones that move away from our present preconceptions about what software applications are. As he put it, if Word is the limit of your expectations... The best software he says is yet to come. While this may appear at first sight simply obvious, we have changed dramatically our expctations of what a computer can do and indeed what one is and there is no reason to expect that this evolution will not continue.
Citing applications such as musical composition and performance, content-based image retrieval, facial recognition and “whisperering” (i.e. a system that can identify familiar faces and whisper them in your ear as they approach to avoid those embarassing moments!), personal medical monitoring and diagnosis, etc., he asks how you approach the problem of building software that would meet his criteria of portability across processor generations.
Patterson and his co-authors have long argued that there are only a small core of basic processes that form the heart of most applications. They originally thought seven, so became known as the Seven Dwarves, but then the count rose to thirteen and became the Thirteen Dwarves. The Dwarves have now become “Motifs”, but the underlying analysis is the same. These are in some sense fundamental elements which need to be available to the programmer. This reduction is of course very controversial among Computer Scientists who cite more algorithms. However the Patterson argument is that these form the majority of cases. Hardware in future should be optimised to support the Motifs, in an 80:20 strategy. The remaining applications would then be built using other technologies, perhaps extending the Dwarf Count.
This is a pattern-based aproach and to a great extent that is where this talk was leading. The software layers of the future would according to Patterson be built using the motifs within patterns, frameworks or similar. The need then is for “auto-tuning” of the software to meet the changing architectural demands of each new generation of hardware. Core count growth will inevitably lead to a vast panoply of differing hardware, for which we can't expect to have individual ports. Instead auto-tuners, aware of the underlying structure which may be very diverse, will tailor the implementation.This brings with it issues of testing for the “correctness” of the parallelism so imposed. That is in itself a massive issue and one that Patterson skirted around.
Is this the way of the future? It is a strategy in which it is an underlying layer that hides the processor details from the programmer and grants flexibility. It is not guaranteed to work, but does resolve the issues associated with processor dependence. Space doen't allow me to take this discussion further, but it is one to which we will surely return.