4.5. Specifying compilers and flags
Changing the compilers that Open MPI uses to build itself uses the
standard GNU Autoconf mechanism of setting special environment variables
either before invoking
configure or on the
The following environment variables are recognized by
CC: C compiler to use
CFLAGS: Compile flags to pass to the C compiler
CPPFLAGS: Preprocessor flags to pass to the C compiler
CXX: C++ compiler to use
CXXCFLAGS: Compile flags to pass to the C++ compiler
CXXCPPFLAGS: Preprocessor flags to pass to the C++ compiler
FC: Fortran compiler to use
FCFLAGS: Compile flags to pass to the Fortran compiler
LDFLAGS: Linker flags to pass to all compilers
LIBS: Libraries to pass to all compilers (it is rarely necessary for users to need to specify additional
PKG_CONFIG: Path to the
Open MPI head of development does not contain any C++ code. The only
configure runs with the C++ compiler is for
the purposes of determining an appropriate value for
to use in the
mpic++ wrapper compiler. The
CXXCPPFLAGS values are only used in these
configure checks to ensure that the C++ compiler works.
For example, to build with a specific instance of
shell$ ./configure \ CC=/opt/gcc-a.b.c/bin/gcc \ CXX=/opt/gcc-a.b.c/bin/g++ \ FC=/opt/gcc-a.b.c/bin/gfortran ...
Here’s another example, this time showing building with the Intel compiler suite:
shell$ ./configure \ CC=icc \ CXX=icpc \ FC=ifort ...
The Open MPI community generally suggests using the above
command line form for setting different compilers (vs. setting
environment variables and then invoking
above form will save all variables and values in the
file, which makes post-mortem analysis easier if problems occur.
Note that the flags you specify must be compatible across all the compilers. In particular, flags specified to one language compiler must generate code that can be compiled and linked against code that is generated by the other language compilers. For example, on a 64 bit system where the compiler default is to build 32 bit executables:
# Assuming the GNU compiler suite shell$ ./configure CFLAGS=-m64 ...
will produce 64 bit C objects, but 32 bit objects for Fortran. These codes will be incompatible with each other, and Open MPI will not build successfully. Instead, you must specify building 64 bit objects for all languages:
# Assuming the GNU compiler suite shell$ ./configure CFLAGS=-m64 FCFLAGS=-m64 ...
The above command line will pass
-m64 to all the compilers, and
therefore will produce 64 bit objects for all languages.
Note that setting
CFLAGS (etc.) does not affect the
flags used by the wrapper compilers. In the above, example, you may
also need to add
-m64 to various
shell$ ./configure CFLAGS=-m64 FCFLAGS=-m64 \ --with-wrapper-cflags=-m64 \ --with-wrapper-cxxflags=-m64 \ --with-wrapper-fcflags=-m64 ...
Failure to do this will result in MPI applications failing to compile / link properly.
See the Customizing wrapper compiler behavior section for more details.
Note that if you intend to compile Open MPI with a
make other than
the default one in your
PATH, then you must either set the
environment variable before invoking Open MPI’s
configure script, or
MAKE=your_make_prog to configure. For example:
shell$ ./configure MAKE=/path/to/my/make ...
This could be the case, for instance, if you have a shell alias for
make, or you always type
gmake out of habit. Failure to tell
configure which non-default
make you will use to compile Open MPI
can result in undefined behavior (meaning: don’t do that).
Note that you may also want to ensure that the value of
LD_LIBRARY_PATH is set appropriately (or not at all) for your build
(or whatever environment variable is relevant for your operating
system). For example, some users have been tripped up by setting to
use a non-default Fortran compiler via the
FC environment variable,
but then failing to set
LD_LIBRARY_PATH to include the directory
containing that non-default Fortran compiler’s support libraries.
This causes Open MPI’s
configure script to fail when it tries to
compile / link / run simple Fortran programs.
It is required that the compilers specified be compile and link compatible, meaning that object files created by one compiler must be able to be linked with object files from the other compilers and produce correctly functioning executables.