Passing it on

Computing’s rapid evolution demands equally fast changes in software. Users want programs that run on any machine, from a laptop to a massively parallel supercomputer. But they don’t want to have to be computer scientists to make it work.

To do that, says Argonne National Laboratory’s Ewing “Rusty” Lusk, you need a standard so that the same parallel programs can run on a wide range of computers. The Message Passing Interface (MPI) standard aims for that goal, but it’s a moving target. MPI must adapt to the times, and the times are always changing.

MPI is necessary because a distributed-memory system – in which a computer has multiple processors, each with its local memory – requires a network to share data among processors. Message passing moves data between the local memories of different processors.

Multiple MPI implementations exist. One of them is MPICH, where “CH” stands for chameleon – MPI that adapts to its surroundings, which here means a computer and its operating system (See sidebar, “Changing a chameleon’s color.”). Its latest iteration, MPICH2, is used by some of the top HPC companies.

For example, Microsoft’s Windows HPC Server includes an MPI implementation called Microsoft MPI that is based on Argonne’s MPICH2. Cray, the supercomputing company, also uses MPICH2 for its latest XE6 systems, “and (it) is scaling to over 220,000 cores on the Cray XT5 at Oak Ridge National Laboratory,” says Barry Bolding, Cray products division vice president.

Lusk, who leads the MPI standard implementation team at Argonne, notes that “MPICH2’s real impact is that it has been taken up by the parallel computer vendors and incorporated into their system software. Thus, anyone who runs a parallel program on IBM, Cray, Intel or other parallel computers is using MPICH2, even though they might not know it.”

MPICH2’s wide adoption in parallel system software spans the industry and application spectrum, from Pratt & Whitney (aircraft engine design) and AeroDynamic Solutions (three-dimensional simulations of fluid flow) to Procter & Gamble (plastic bottle design). In molecular biology, National Cancer Institute researchers have used MPICH2 on a cluster of linked off-the shelf home computers to run FastMEDUSA, which uses gene-expression data to construct gene regulatory networks.

Much of what makes MPICH2 appealing to vendors and researchers is the implementation of best practices and careful documentation. For example, the developers have used a coding-standard document to ensure the code is well written. Every line of code was compared against the coding standard. MPICH2 also includes other features, such as a bug-tracking system and a consortium that supports MPICH2 on different platforms.

Overall, MPICH2 is efficient, Lusk says, because lots of research went into almost every aspect of it. “It’s the incorporation of serious computer science research that sets it apart.” Some of that research is what makes MPICH2 flexible enough to run on a wide range of computers. “It does some things different if it’s running on 100,000 or 1,000 CPUs.”

Argonne’s MPICH2 software is open source and freely available for download. Argonne scientists also run the lab’s message-passing interface on their own parallel computers to test it and have reported their findings in upward of 100 peer-reviewed papers, Lusk says. “It’s never finished, and we release an update about every six months.”

Extreme portability creates one of MPICH2’s most desirable features, but it also generates one of the most significant challenges for developers, Lusk says. “It’s easy to make this robust if you’re targeting a single type of machine” but difficult when targeting several types.

When all goes smoothly, a user downloads the source code for MPICH2, types a UNIX make command, and MPICH2 works fine in about 15 minutes. “But if there are any weird settings on the person’s computer, it can trigger funny error messages.”

So the MPICH2 team must anticipate how its software will run on various machines using a variety of operating systems and with an endless ensemble of possible settings on a specific computer. When such error messages arise, Lusk and his colleagues explore the problem and look for a solution.

To automate the process, the MPICH2 software includes sections of code that test a user’s computer before starting a build. These small programs identify the computer and its operating system, as well as noting many of its settings.

Although MPICH2 will run on a laptop, the value depends on the application at hand. If all a user wants to run is Microsoft Word, for instance, it’s not worth the trouble of installing MPICH2. But if a laptop includes four processors and a user is running an application that might go four times faster, MPICH2 could be just the thing.

In life sciences, for example, laptop applications routinely need improved speed to run gene-sequencing tools or a wide range of simulations, from compounds docking on and blocking disease-related receptors to models that explore a wide range of biochemical pathways.

For MPICH2 on a laptop, however, the real benefits could be yet to come. “We’re headed toward an even greater degree of parallelism in consumer processors,” Lusk says. His laptop has four processors, and he expects that the next time he buys one it will have 16. Although most laptop users don’t even think of coding and prefer to leave that to the device manufacturers, they do care about performance, and all users benefit when vendors implement the latest MPI standards.

But “the real boost from message passing will come at computational science’s highest end,” Lusk says. To go to exascale, for example, systems could have billions of processors. That day is many years of research away, but for now, it appears that some form of message passing interface is likely to remain the method of choice to handle communication.