"Compilers are the underpinnings of the most important software," says James Reinders, Chief Evangelist and Director of Marketing and Business Development for Intel Software Products. "They build operating systems, all the infrastructure, most of the programming languages, millions of applications." These crucial tools of the programming craft are getting smarter, but certain developments in hardware and software mandate that they get a lot smarter.
First, evidence that compilers are getting smarter: "This week's news about a company named Tilera focused on two fronts: It is an MIT spin-off and its first release is a 64-core-processor called the 'Tile64.' But focusing on these two issues somewhat misses the point. The real news about Tilera is the software—specifically, its Multicore Development Environment." (Dr. Dobb's Report, August 21, 2007.) What makes Tilera's MDE big news is its multitiered approaches to parallelism, including SIMD compiler intrinsics to enable fine-grain parallelism across those 64 cores.
Second, why compilers need to get a lot smarter: In a widely cited paper earlier this summer, researchers at the University of Illinois at Urbana-Champaign presented a programming model for thousand-core microprocessors. "In such a model," they argue, "compilers and related tools require much more advanced program analysis capabilities and programmer assertions than what are currently available...to drive automatic or interactive parallel code generation tools." ("Implicitly Parallel Processing Models for Thousand-Core Microprocessors," Hwu et al., DAC 2007.)
In short, if multicore processors are the future, compilers are going to need to get smarter.
Your Parallel Future
But are multicore processors the future?
Microsoft's David Tarditi (Principal Researcher, Advanced Compiler Technology group) thinks so. "Multicore computing, and more generally parallelism, is really going to be important," he says. "Clock speeds aren't increasing. Most of the performance increase is going to have to come from parallelism."
Intel's Geoff Lowney, director of Compiler and Architecture Advanced Development, agrees: "The most significant technological advance we will see in compilers in the next few years will be the widespread support for parallelism. Almost all future processors will have multiple cores. Over the next few years, almost all languages will develop extensions to deal with parallelism, and compilers will focus on the problem of mapping computation across multiple cores." Hardware and software parallelism that was formerly the exclusive province of scientific computing and GPU programming is the future of software development generally.
So can we expect super-smart compilers in a few years that efficiently and automatically parallelize your algorithms and legacy code? Probably not. The consensus of those we spoke with seems to be that compilers can't possibly be smart enough. "It is very unlikely," in Lowney's opinion, that "compilers will be able to parallelize serial programs automatically; the compiler will rely on the programmer to express parallelism explicitly, using new language constructs."
At least, that's the view from the compiler research labs. Lowney works in research at Intel. Reinders, also at Intel, takes a more near-term, pragmatic view. Because compilers are the underpinnings of our most important software, he says, in the short term any drastic change in the way compilers work is off the table. "We don't want radical change for users. Our users tell us 'don't make us edit our Makefiles!' We are trying hard to move to parallelism without radical compiler changes. The real work needs to be 'under the hood' or elsewhere (other than compilers)."
Got it: Compilers must get drastically smarter to deal with tomorrow's (and today's) multicore processors, and drastic change in compiler technology is disruptive. Clearly, there is a bumpy ride ahead.
