ADC Home > Reference Library > Reference > Mac OS X > Mac OS X Man Pages

 

This document is a Mac OS X manual page. Manual pages are a command-line technology for providing documentation. You can view these manual pages locally using the man(1) command. These manual pages come from many different sources, and thus, have a variety of writing styles.

For more information about the manual page format, see the manual page for manpages(5).



mpicc(1)                                          Open MPI                                          mpicc(1)



NAME
       mpicc -- Open MPI C wrapper compiler

SYNTAX
       mpicc [-showme|-showme:compile|-showme:link] ...

OPTIONS
       -showme
              Do  not invoke the underlying compiler.  Instead, show the command line that would be executed
              to compile the program.  NOTE: If a non-filename argument is passed on the command  line,  the
              -showme  option will not display any additional flags.  For example, both "mpicc --showme" and
              "mpicc --showme my_source.c" will show all the wrapper-supplied flags.  But "mpicc -showme -v"
              will only show the underlying compiler name and "-v".

       -showme:compile
              Do  not invoke the underlying C compiler.  Instead, show the compiler flags that would be sup-plied supplied
              plied to the C compiler.

       -showme:link
              Do not invoke the underlying C compiler.  Instead, show the linker flags that  would  be  sup-plied supplied
              plied to the C compiler.

       See the man page for your underlying compiler for other options that can be passed through mpicc

DESCRIPTION
       Conceptually,  the  role  of  these commands is quite simple: transparently add relevant compiler and
       linker flags to the user's command line that are necessary to compile / link Open MPI  programs,  and
       then invoke the underlying compiler to actually perform the command.

       As  such,  these commands are frequently referred to as "wrapper" compilers because they do not actu-ally actually
       ally compile or link applications themselves; they only add in command  line  flags  and  invoke  the
       back-end compiler.

   Background
       Open  MPI  is  comprised of three software layers: OPAL (Open Portable Access Layer), ORTE (Open Run-Time RunTime
       Time Environment), and OMPI (Open MPI).  There are wrapper compilers for  each  layer;  each  layer's
       wrapper  only  links in the libraries relevant for that layer.  Specifically, each layer provides the
       following wrapper compilers:

       OPAL
           opalcc and opalc++

       ORTE
           ortecc and ortec++

       OMPI
           mpicc, mpic++, mpicxx, mpiCC (only on systems  with  case-senstive  file  systems),  mpif77,  and
           mpif90.  Note that mpic++, mpicxx, and mpiCC all invoke the same underlying C++ compiler with the
           same options.  All are provided as compatibility with other MPI implementations.

       The Fortran wrapper compilers for MPI (mpif77 and mpif90) will be  inoperative  and  will  return  an
       error on use if Fortran 77 / Fortran 90 support was not built into the MPI layer.

   Overview
       mpicc  is  a  convenience wrappers for the underlying C compiler.  Translation of an Open MPI program
       requires the linkage of the Open MPI-specific libraries which may not reside in one of  the  standard
       search  directories of ld(1).  It also often requires the inclusion of header files what may also not
       be found in a standard location.

       mpicc passes its arguments to the underlying C compiler along with the -I, -L and -l options required
       by Open MPI programs.

       The  Open  MPI  Team strongly encourages using the wrapper compilers instead of attempting to link to
       the Open MPI libraries manually.  This allows the specific implementation of Open MPI to change with-out without
       out  forcing changes to linker directives in users' Makefiles.  Indeed, the specific set of flags and
       libraries used by the wrapper compilers depends on how Open MPI was configured and built; the  values
       can change between different installations of the same version of Open MPI.

       Indeed,  since  the wrappers are simply thin shells on top of an underlying compiler, there are very,
       very few compelling reasons not to use mpicc.  When it is not possible to use the wrappers  directly,
       the  -showme:compile  and  -showme:link  options  should be used to determine what flags the wrappers
       would have used.  For example:

       shell$ cc -c file1.c `mpicc -showme:compile`

       shell$ cc -c file2.c `mpicc -showme:compile`

       shell$ cc file1.o file2.o `mpicc -showme:link` -o my_mpi_program

NOTES
       It is possible to make the wrapper compilers multi-lib aware.  That is, the  libraries  and  includes
       specified  may  differ  based on the compiler flags specified (for example, with the GNU compilers on
       Linux, a different library path may be used if -m32 is seen versus -m64 being seen).  This is not the
       default  behavior in a standard build, but can be activated (for example, in a binary package provid-ing providing
       ing both 32 and 64 bit support).  More information can be found at:

         https://svn.open-mpi.org/trac/ompi/wiki/compilerwrapper3264

FILES
       The string that the wrapper compilers insert into the command line  before  invoking  the  underlying
       compiler  are  stored  in  a  text  file created by Open MPI and installed to $pkgdata/mpicc-wrapper-data.txt, $pkgdata/mpicc-wrapperdata.txt,
       data.txt, where $pkgdata is typically $prefix/share/openmpi, and  $prefix  is  the  top  installation
       directory of Open MPI.

       It  is rarely necessary to edit this file, but it can be examined to gain insight into what flags the
       wrappers are placing on the command line.

ENVIRONMENT VARIABLES
       By default, the wrappers use the compilers that were selected when Open MPI  was  configured.   These
       compilers  were  either found automatically by Open MPI's "configure" script, or were selected by the
       user in the CC, CXX, F77, and/or FC environment variables before "configure" was invoked.   Addition-ally, Additionally,
       ally, other arguments specific to the compiler may have been selected by configure.

       These  values can be selectively overridden by either editing the text files containing this configu-ration configuration
       ration information (see the FILES section), or by setting selected environment variables of the  form
       "OMPI_value".

       Valid value names are:

       CPPFLAGS
              Flags added when invoking the preprocessor (C or C++)

       LDFLAGS
              Flags added when invoking the linker (C, C++, or Fortran)

       LIBS   Libraries added when invoking the linker (C, C++, or Fortran)

       CC     C compiler

       CFLAGS C compiler flags

       CXX    C++ compiler

       CXXFLAGS
              C++ compiler flags

       F77    Fortran 77 compiler

       FFLAGS Fortran 77 compiler flags

       FC     Fortran 90 compiler

       FCFLAGS
              Fortran 90 compiler flags



OMPI                                              Open MPI                                          mpicc(1)

Did this document help you?
Yes: Tell us what works for you.
It’s good, but: Report typos, inaccuracies, and so forth.
It wasn’t helpful: Tell us what would have helped.