This directory contains some examples of the use of MPI, the Message Passing Interface, with a C program.
MPI is a library of message passing routines. The library allows a user to write a program in a familiar language, such as C, C++, FORTRAN77 or FORTRAN90, and carry out a computation in parallel on an arbitrary number of cooperating computers.
A remarkable feature of MPI is that the user writes a single program which runs on all the computers. However, because each computer is assigned a unique identifying number, it is possible for different actions to occur on different machines, even though they run the same program:
if ( I am processor A ) then
add a bunch of numbers
else if ( I am processor B ) then
multipy a matrix times a vector
end
Another feature of MPI is that the data stored on each computer is entirely separate from that stored on other computers. If one computer needs data from another, or wants to send a particular value to all the other computers, it must explicitly call the appropriate library routine requesting a data transfer. Depending on the library routine called, it may be necessary for both sender and receiver to be "on the line" at the same time (which means that one will probably have to wait for the other to show up), or it is possible for the sender to send the message to a buffer, for later delivery, allowing the sender to proceed immediately to further computation.
Here is a simple example of what a piece of the program would look like, in which the number X is presumed to have been computed by processor A and needed by processor B:
if ( I am processor A ) then
call MPI_Send ( X )
else if ( I am processor B ) then
call MPI_Recv ( X )
end
Often, an MPI program is written so that one computer supervises the work, creating data, issuing it to the worker computers, and gathering and printing the results at the end. Other models are also possible.
It should be clear that a program using MPI to execute in parallel will look much different from a corresponding sequential version. The user must divide the problem data among the different processes, rewrite the algorithm to divide up work among the processes, and add explicit calls to transfer values as needed from the process where a data item "lives" to a process that needs that value.
A C program, subroutine or function that calls any MPI function, or uses an MPI-defined variable, must include the line
include "mpi.h"
You probably compile and link your program with a single command, as in
cc myprog.c
Depending on the computer that you are using, you may be able
to compile an MPI program with a similar command, which automatically
locates the include file and the compiled libraries that you will
need. This command is likely to be:
mpicc myprog.c
Interactive MPI Runs
Some systems allow users to run an MPI program interactively.
You do this with the mpirun command:
mpirun -np 4 a.out
This command requests that the executable program a.out
be run, right now, using 4 processors.
The mpirun command may be a convenience for beginners,
with very small jobs, but this is not the way to go once you
have a large lengthy program to run! Also, what actually happens
can vary from machine to machine. When you ask for 4 processors,
for instance,
-
in the best case, mpirun automatically finds three other
machines just like the one you are one, copies your program
to them, and starts your program on all four.
-
in a less good case, there are four processors on your current
machine, so the memory is divided up among them and your program
runs;
-
in a worse case, there are less than four processors available,
so, as necessary, one processor will "time share", and run two
or more of your processes alternately.
Related Data and Programs:
CONDOR
is a remote queueing system which
is used to submit MPI jobs to the FSU SCS clusters.
HEAT_MPI
is a C program which
solves the 1D time dependent heat equation using the finite difference
method, with parallelization from MPI.
LAMMPS
is a FORTRAN77 molecular dynamics simulation program which
uses MPI. A serial version can be created by linking the
program with the MPI_STUBS library.
METIS
is a C library (and a family of executable programs
based on it) which can partition the nodes of a graph or the
elements of a finite element mesh in a way suitable for
further treatment by parallel processing.
MPI examples are also available in
a C++ version, and
a FORTRAN77 version, and
a FORTRAN90 version.
MPI_CONDOR
is a directory of CONDOR scripts which
run C programs using MPI on the FSU cluster system.
MPI_ECLIPSE
is a directory of LoadLeveler scripts
for running C programs using MPI
on the Eclipse IBM SP at FSU.
MPI_INTRODUCTION
is a one page introduction to MPI.
MPI_MORE_INFO
contains a list of references, web sites, examples and
tutorials on MPI.
MPI_STUBS
is a C library of "stub" MPI routines, which allows
a user to compile, load, and possibly run an MPI program on a
serial machine.
MPI_SYSX
is a directory of PBS scripts
for running C programs using MPI
on System X.
OPEN_MP
is a directory of C examples which
illustrate the use of the OpenMP application program interface
for carrying out parallel computations in a shared memory environment.
PETSC
is a scientific programming library for parallel programming, which
requires MPI in order to run.
PLTMG_SINGLE
is a FORTRAN77 finite element program which
can be compiled and run with the MPI library.
PTHREADS
is a set of C examples which
illustrate the use of the POSIX thread library to carry out
parallel program execution.
QUAD_MPI
is a C program which
approximates an integral using a quadrature rule, and carries out the
computation in parallel using MPI.
RANDOM_MPI,
a C program which
demonstrates one way to generate the same sequence of random numbers
for both sequential execution and parallel execution under MPI.
SATISFIABILITY_MPI
is a C program which
demonstrates, for a particular circuit, an exhaustive search
for solutions of the circuit satisfiability problem, using MPI to
carry out the calculation in parallel.
SGE
is the Sun Grid Engine, a remote queueing system.
Reference:
-
William Gropp, Steven Huss-Lederman, Andrew Lumsdaine, Ewing Lusk,
Bill Nitzberg, William Saphir, Marc Snir,
MPI: The Complete Reference,
Volume II: The MPI-2 Extensions,
Second Edition,
MIT Press, 1998,
ISBN13: 978-0-262-57123-4,
LC: QA76.642.M65.
-
William Gropp, Ewing Lusk, Anthony Skjellum,
Using MPI: Portable Parallel Programming with the
Message-Passing Interface,
Second Edition,
MIT Press, 1999,
ISBN: 0262571323,
LC: QA76.642.G76.
-
William Gropp, Ewing Lusk, Rajiv Thakur,
Using MPI-2: Advanced Features of the Message-Passing
Interface,
Second Edition,
MIT Press, 1999,
ISBN: 0262571331,
LC: QA76.642.G762.
-
Stan Openshaw, Ian Turton,
High Performance Computing and the Art of Parallel Programming:
an Introduction for Geographers, Social Scientists, and
Engineers,
Routledge, 2000,
ISBN: 0415156920,
LC: QA76.88.O64.
-
Peter Pacheco,
Parallel Programming with MPI,
Morgan Kaufman, 1996,
ISBN: 1558603395,
LC: QA76.642.P3.
-
Sudarshan Raghunathan,
Making a Supercomputer Do What You Want: High Level Tools for
Parallel Programming,
Computing in Science and Engineering,
Volume 8, Number 5, September/October 2006, pages 70-80.
-
Marc Snir, Steve Otto, Steven Huss-Lederman, David Walker,
Jack Dongarra,
MPI: The Complete Reference,
Volume I: The MPI Core,
Second Edition,
MIT Press, 1998,
ISBN: 0-262-69216-3,
LC: QA76.642.M65.
-
Scott Vetter, Yukiya Aoyama, Jun Nakano,
RS/600 SP: Practical MPI Programming,
IBM Redbooks, 1999,
ISBN: 0738413658.
Several useful web sites include:
-
The MPI web site at Argonne National Lab:
http://www-unix.mcs.anl.gov/mpi/
-
The Message Passing Interface Forum,
MPI: A Message Passing Interface Standard,
1995,
Available online from
the MPI Forum.
-
The Message Passing Interface Forum,
MPI-2: Extensions to the Message Passing Interface,
1997,
Available online from
the MPI Forum.
Examples and Tests:
BONES passes a vector of real data from one process to
another. It was used as an example in an introductory MPI workshop.
-
bones.c,
the source code;
-
bones.csh,
a C-shell script to compile and run the program using MPIRUN.
-
bones_output.txt,
the output file;
BUFFON_LAPLACE demonstrates how parallel Monte Carlo
processes can set up distinct random number streams.
-
buffon_laplace.c,
the source code;
-
buffon_laplace.csh,
a C-shell script to compile and run the program using MPIRUN.
-
buffon_laplace_output.txt,
the output file;
DAY1_EX3 works out exercise #3 assigned after day 1 of a
workshop on MPI. The instructions were to have process 1 generate some
integers, send them to process 3 which used some of those values to
generate some real numbers which were then sent
back to process 1.
-
day1_ex3.c,
the source code;
-
day1_ex3.csh,
a C-shell script to compile and run the program using MPIRUN.
-
day1_ex3_output.txt,
the output file;
HELLO simply has each process say hello:
-
hello.c,
the source code;
-
hello.csh,
a C-shell script to compile and run the program using MPIRUN.
-
hello_output.txt,
the output file;
INTERVALS estimates an integral by dividing an interval
into subintervals, and having the servant processes estimate
the integral over each subinterval.
-
intervals.c,
the source code;
-
intervals.csh,
a C-shell script to compile and run the program using MPIRUN.
-
intervals_output.txt,
the output file;
MATVEC computes a matrix-vector product c = A * b,
giving each process a copy of the vector b, and using self-scheduling
to let any process have the next row of A to work on when it is ready.
Arrays are allocated dynamically. The "math.h" include file
is needed, as is the run-time math library.
-
matvec.c,
the source code;
-
matvec.csh,
a C-shell script to compile and run the program using MPIRUN.
-
matvec_output.txt,
the output file;
MONTE CARLO computes PI by the Monte Carlo method, testing
whether points in the unit square are in the unit circle.
-
monte_carlo.c,
the source code;
-
monte_carlo.csh,
a C-shell script to compile and run the program using MPIRUN.
-
monte_carlo_output.txt,
the output file;
POISSON_SERIAL solves the Poisson equation on a 2D grid.
This version of the program does not use MPI, and is provided for
comparison.
-
poisson_serial.c,
the source code;
-
poisson_serial.csh,
a C-shell script to compile and run the program.
-
poisson_serial_output.txt,
the output file;
PRIME_SUM computes the sum of the prime numbers between 2 and N.
-
prime_sum.c,
the source code;
-
prime_sum.csh,
a C-shell script to compile and run the program using MPIRUN.
-
prime_sum_output.txt,
the output file;
QUADRATURE integrates a function f(x) over an interval;
-
quadrature.c,
the source code;
-
quadrature.csh,
a C-shell script to compile and run the program using MPIRUN.
-
quadrature_output.txt,
the output file;
SEARCH searches a list of numbers for all
occurrences of a target value.
-
search.c,
the source code;
-
search.csh,
a C-shell script to compile and run the program using MPIRUN.
-
search_output.txt,
the output file;
SUM adds a list of numbers.
-
sum.c,
the source code;
-
sum.csh,
a C-shell script to compile and run the program using MPIRUN.
-
sum_output.txt,
the output file;
TASK_DIVISION is a serial code that simply suggests how
T tasks could automatically and evenly be divided among
P processors.
-
task_division.c,
the source code;
-
task_division.csh,
a C-shell script to compile and run the program.
-
task_division_output.txt,
the output file;
TYPE sets up a user-defined datatype, and sends and
receives data in this form.
-
type.c,
the source code;
-
type.csh,
a C-shell script to compile and run the program using MPIRUN.
-
type_output.txt,
the output file;
VERSION calls a routine that reports the
version and subversion of MPI.
-
version.c,
the source code;
-
version.csh,
a C-shell script to compile and run the program using MPIRUN.
-
version_output.txt,
the output file;
You can go up one level to
the C source codes.
Last revised on 24 October 2007.