MPI & PVM Comparison

Message passing is a programming paradigm where you directly control the flow of operations and data within your parallel program. A message-passing library lets you explicitly tell each processor what to do and provides a mechanism for you to transfer data between processes.

Message-passing libraries can be implemented using two separate standards, MPI (Message Passing Interface) and PVM (Parallel Virtual Machine).

PVM, written at Oak Ridge National Lab, is a portable heterogeneous message-passing system. It provides tools for inter-process communication, process spawning, and execution on multiple architectures. The PVM standard is well defined, and PVM has been a standard tool for parallel computing for several years.

MPI came into the mainstream more recently than PVM, but it is a mature standard that has been available for over a decade. The public domain implementation was written at Argonne National Lab and is currently available for virtually all major computer architectures. MPI is intended primarily for data-parallel problems. Therefore, it does not have the flexibility of PVM's dynamic process spawning, but its collective operations (like gather-scatter operations) and asynchronous message passing capabilities (asynchronous sends and receives) are much more sophisticated and configurable than those in PVM.

When to Use Message Passing

The decision to use message passing to implement your parallel code should not be taken lightly. Using message passing to implement code is often substantially more work than using compiler directives. For many applications that involve mostly array operations, the native Fortran or C compiler produces as good if not better performing code than a message-passing implementation. However, there are several situations in which message passing is the best solution to your parallel programming problem:

• If you already have a large application written in PVM or MPI, it should compile and run without difficulty.
• If your code is "embarrassingly parallel" on a coarse level, you may want to consider message passing. For instance, if your code has an inherently serial section that must be run independently multiple times, you may want to consider writing a wrapper to your serial code using a message-passing library.
• If your code cannot be parallelized by making parallel "do" loops, it may not parallelize well using the compilers. However, there are codes that fall into this category where the algorithm is parallelizable. In this case, you would have to do a fairly substantial amount of work to create a message-passing version of your code. If you did so, however, your code may perform better than if you simply used the compiler and compiler directives.
• If you require your code to be highly portable across parallel supercomputing architectures, you should consider MPI and High Performance Fortran (HPF). Both are very portable and widely available ways to implement data-parallel codes.

Source: The National Center for Supercomputing Applications, University of Illinois

Contact us to receive a free price quote and to discuss your specific high-performance system requirements. We'll listen to your requests and help you put together a system or cluster with a configuration that works to fit your computing needs.