MPI_ECLIPSE
Submitting FORTRAN90 MPI Programs to ECLIPSE

MPI_ECLIPSE is an example directory of FORTRAN90 programs which illustrate the use of LoadLeveler scripts on the Eclipse IBM SP system at Florida State University, in order to submit and run FORTRAN90 programs that use MPI, the Message Passing Interface.

Related Data and Programs:

CONDOR is the remote queueing system used to submit MPI jobs to the FSU SCS clusters.

LAMMPS is an executable 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 is the Message Passing Interface, which allows programs to execute in parallel.

MPI_CONDOR is a directory of sample CONDOR scripts for running FORTRAN90 programs under MPI on the FSU cluster.

MPI_ECLIPSE is also available in a C version and a C++ version and a FORTRAN77 version.

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 FORTRAN90 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 sample PBS scripts for running FORTRAN90 programs under MPI on System X.

OPEN_MP is a simple system for parallel programming which relies on the use of shared memory.

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.

SGE is the Sun Grid Engine, a remote queueing system.

Reference:

1. 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.

Examples and Tests:

BONES passes a vector of real data from one process to another. It was used as an introductory example in an MPI workshop.

• bones.f90, the source code;
• bones.ll, a LoadLeveler script to compile and run the program.
• bones_output.txt, the resulting output;

BUFFON_LAPLACE demonstrates how parallel Monte Carlo processes can set up distinct random number streams.

• buffon_laplace.f90, the source code;
• buffon_laplace.ll, a LoadLeveler script to compile and run the program.
• buffon_laplace_output.txt, the resulting output from Eclipse;

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.f90, the source code;
• day1_ex3.ll, a LoadLeveler script to compile and run the program.
• day1_ex3_output.txt, the resulting output;

HELLO simply prints out "Hello, world!" from each MPI process.

• hello.f90, the source code;
• hello.ll, a LoadLeveler script to compile and run the program.
• hello_output.txt, the resulting output;

INTERVALS estimates an integral by dividing an interval into subintervals, and having the servant processes estimate the integral over each subinterval.

• intervals.f90, the source code;
• intervals.ll, a LoadLeveler script to compile and run the program.
• intervals_output.txt, the output from a run on Eclipse;

MATMAT multiplies two matrices.

• matmat.f90, the source code;
• matmat.ll, a LoadLeveler script to compile and run the program.
• matmat_output.txt, the resulting output;

MATVEC multiplies a matrix times a vector.

• matvec.f90, the source code;
• matvec.ll, a LoadLeveler script to compile and run the program.
• matvec_output.txt, the resulting output;

MONTE_CARLO computes PI by the Monte Carlo method, testing whether random points in the unit square are in the unit circle.

• monte_carlo.f90, the source code;
• monte_carlo.ll, a LoadLeveler script to compile and run the program.
• monte_carlo_output.txt, the output from a run on Eclipse;

POISSON_BAND is a revision to POISSON_SERIAL, which divides the physical region into horizontal strips, assigns a process to each strip, and uses MPI_SEND and MPI_RECV to pass interface data between processes.

• poisson_band.f90, the source code;
• poisson_band.ll, a LoadLeveler script to compile and run the program.
• poisson_band_output.txt, the resulting output;

POISSON_BAND2 is a revision to POISSON_BAND, which uses the nonblocking communication routines MPI_ISEND and MPI_IRECV to pass interface data between processes.

• poisson_band2.f90, the source code;
• poisson_band2.ll, a LoadLeveler script to compile and run the program.
• poisson_band2_output.txt, the resulting output;

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.f90, the source code;
• poisson_serial.ll, a LoadLeveler script to compile and run the program.
• poisson_serial_output.txt, the resulting output;

QUADRATURE estimates an integral.

• quadrature.f90, the source code;
• quadrature.ll, a LoadLeveler script to compile and run the program.
• quadrature_output.txt, the output from Eclipse;

SEARCH searches a vector for occurrences of a particular value.

• search.f90, the source code;
• search.ll, a LoadLeveler script to compile and run the program.
• search_output.txt, the output;

TYPE demonstrates the use of a user-defined datatype.

• type.f90, the source code;
• type.ll, a LoadLeveler script to compile and run the program.
• type_output.txt, the resulting output;

VERSION calls an MPI routine that returns the version and subversion levels of the MPI library.

• version.f90, the source code;
• version.ll, a LoadLeveler script to compile and run the program.
• version_output.txt, the resulting output;

You can go up one level to the FORTRAN90 source codes.