Manticore Wins Big
NSF Awards $500,000 for Multicore Research
Ever notice how computers aren’t becoming faster the way they used to? It’s not just you: the NSF thinks so too, and recently awarded the Manticore project $500,000 to speed things up again.
The Manticore project, a joint collaboration between between faculty and students at the University of Chicago Computer Science and Toyota Technical Institute at Chicago, has received a three-year NSF grant for $500,000. The grant, which started this July, is for the development of a computer language for multi-core processor computer architecture; the group expects to release an alpha version of the language before the upcoming ICFP meeting this September where group members will present two papers, Implicitly Threaded Parallelism in Manticore and A Scheduling Framework for General-Purpose Parallel Languages.
Involved in the project are John Reppy, Professor in Computer Science, Toyota Technical Institute at Chicago (TTI-C) Research Assistant Professor Matthew Fluet, PhD students Adam Shaw, Mike Rainey, and Yingqi Xiao, and fourth-year undergraduate in Math and CS Nic Ford.
Fluet has been working on the project since his arrival at TTI-C two years ago and is very excited to have been selected by the NSF to be a leader in multicore programming.
“[The grants] have all been competitive the last few years so we're all really happy to have made it,” he says. The Manticore project is developing a similarly named programming language designed to take advantage of multi-core and manycore processors, a once emerging technology that has become prevalent in recent years, as processor improvements stagnate and computer architects instead turn to combining processors.
“The Manticore project is motivated by the fact that computer architecture is undergoing a sea change,” explains John Reppy, Professor in Computer Science who heads up the project. “The days of significant increases in processor clock speeds are gone. Instead, architects are turning toward multi-core and, soon, manycore designs.
"Software will have to be rewritten to be able to exploit future improvements in microprocessor performance. That is the motivation for the Manticore project. We are trying to design and implement a general-purpose language that will provide scalable performance on multicore and manycore processors. "
While previous advances in parallel computing have focused on high-level scientific computing, Manticore aims to work with desktop applications on what project members expect to be an average desktop computer in 2012. They project that computer to have at least eight cores, or processing units; for comparison, the latest Intel processors have four cores.
For the commodity computer industry, this is a new problem. In the 1990’s, software developers could rely on the seemingly endless improvement of microprocessor speed to keep consumers upgrading to newer versions. Lately, those drastic improvements have all but stopped, as limits like power consumption, the speed of light, and silicon’s melting point determine a maximum performance for computer chips.
One projection shows processors reaching the temperature of the sun’s surface; comparatively, Intel’s melting microprocessors seem like small change. “I think that people are worried the free lunch is over. If you buy a new computer, it's not necessarily going to run faster; applications could even slow down,” says Mike Rainey, a PhD student involved with the project who will be presenting at the ICFP conference.
One of his colleagues works in the gaming industry and exerts a lot of energy adapting software to this new paradigm in computer architecture, where in the absence of speed-ups on individual processors, developers like Intel simply combine them.
“There are more cores, but cores running at a lower frequency,” Rainey continues. “If you can make programming multicore easier in even one area, such as game development, then you've really accomplished something.
As computer architects continue make computer hardware parallel without pushing the software to catch up, the problem will only worsen. “All the evidence coming out of Intel is that they're only going to add more and more processors,” says Fluet. “The question that we're facing is how to write programs that take advantage of that...The Manticore Project is taking one piece of this by looking at programming technology. What we're asking is, how do we look at a programming language that will easily take advantage of these multi-cores?”
That question, while new to the desktop PC industry, is an old problem for the scientific computing community. As early as the 1960's, computer developers sought performance gains by putting multiple CPUs into a single computer system, creating multiprocessors–a technology analogous to today's multi-core processors–in an attempt to speed up computing.
In theory, adding more processors to a computer dramatically increases performance. The speed-up should be so much that halving the time of a computation only requires doubling the number of processors. In reality, the performance gains turn out to be much lower because not all tasks can be parallelized, or easily divided into smaller subtasks, much in the way that only by giving birth to twins can a woman have more babies.
Parallel programming languages attempt to shore up these shortcomings by coordinating a program’s instructions with each piece of computer hardware and achieve a speed-up by effectively scaling computer programs to the hardware on which they are computed.
But the hardware on commodity machines differs significantly from the hardware behind the massive supercomputers used in scientific computing. Only recently did companies such as Intel start to translate the architecture behind multiprocessor computers into multi-core processors for desktop computers, and the demands of parallel computing shift from massive physics simulations and genome analysis to everyday applications like word-processing and gaming.
Even the software demands of commodity machines differ. Desktop applications range from complicated word processors that simultaneously check spelling and save drafts to video games that involve networking and physical simulations; supercomputing applications tend to be more homogeneous in nature. The end result is that no existing language can successfully capitalize on multi-cored and many-cored desktop computers.
One of the reasons for less-than desired speedup is that the multi-cored computers contain various types of computer architectures, what the group terms heterogeneous, each demanding a separate strategy to optimize parallel performance. “One of the assumptions of our work,” says Rainey, “is that languages will need to mirror some of this heterogeneity to take programs and map them down into the hardware.”
Manticore accomplishes this by focusing on what they have termed heterogeneous parallelism: the ability to orchestrate different granularities of parallelism– the degree to which a task can be done independently of other computations–in the same language. “What we wanted Manticore to do is, say, that if you tie down to one of these granularities, you can't use the features of the other kind,” says Fluet. “We wanted it so that you'd have access to this all but in the same language.”
Manticore allows a specification between both fine and coarse grain parallelism, supported by a scheduler that treats applications demanding coarse grain parallelism–applications that infrequently rely on data from outside processes–differently than those requiring fine grain parallelism–applications which frequently interact with information from outside sources. A scheduler knows to assign a process that has been utilizing fine-grain parallelism to the appropriate processor, one more appropriate for its degree of granularity. “For a lot of parallel applications choosing the right scheduler allows you to get speedup. If you choose a naïve scheduling technique, you'll almost certainly get a slowdown or a weak speedup,” explains Rainey; his Masters paper provided the foundation for Manticore's scheduler and one of the papers that will be presented at the ICFP conference. “What we're doing is building a language with a powerful toolkit for parallel programming. The most important feature is the flexibility in terms of scheduling. We support programmable scheduling policies, and multiple scheduling policies in a single application”
The real test for the language will begin once the language is released and the first programs written in Manticore are tested. At the moment, the project is finalizing the compiler, focusing on sequential optimizations and the modular systems. The NSF grant will last for three years and expectations are that group members will have plenty to keep them busy in the meantime.