kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
CMake/Modules/FindMPI.cmake

678 lines
30 KiB
CMake
Raw Normal View History

Convert builtin help to reStructuredText source files Run the convert-help.bash script to convert documentation: ./convert-help.bash "/path/to/CMake-build/bin" Then remove it.
2013-10-15 19:17:36 +04:00
#.rst:
# FindMPI
# -------
#
# Find a Message Passing Interface (MPI) implementation
#
ENH: Enhance FindMPI module by properly handling backward compatibility with the older module, adding documentation, and coping with multiple include and linker paths
2008-03-31 18:55:32 +04:00
# The Message Passing Interface (MPI) is a library used to write
Convert builtin help to reStructuredText source files Run the convert-help.bash script to convert documentation: ./convert-help.bash "/path/to/CMake-build/bin" Then remove it.
2013-10-15 19:17:36 +04:00
# high-performance distributed-memory parallel applications, and is
# typically deployed on a cluster. MPI is a standard interface (defined
# by the MPI forum) for which many implementations are available. All
# of them have somewhat different include paths, libraries to link
# against, etc., and this module tries to smooth out those differences.
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
#
FindMPI: Improve documentation formatting
2016-04-09 11:05:27 +03:00
# Variables
# ^^^^^^^^^
FindMPI: Fix documentation formatting Adjust whitespace to make the output of "--help-module FindMPI" look good. Also separate the comment containing the copyright and license notice so it does not appear in the documentation.
2011-03-16 17:11:33 +03:00
#
Convert builtin help to reStructuredText source files Run the convert-help.bash script to convert documentation: ./convert-help.bash "/path/to/CMake-build/bin" Then remove it.
2013-10-15 19:17:36 +04:00
# This module will set the following variables per language in your
# project, where <lang> is one of C, CXX, or Fortran:
#
# ::
#
# MPI_<lang>_FOUND TRUE if FindMPI found MPI flags for <lang>
# MPI_<lang>_COMPILER MPI Compiler wrapper for <lang>
# MPI_<lang>_COMPILE_FLAGS Compilation flags for MPI programs
# MPI_<lang>_INCLUDE_PATH Include path(s) for MPI header
# MPI_<lang>_LINK_FLAGS Linking flags for MPI programs
# MPI_<lang>_LIBRARIES All libraries to link MPI programs against
#
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# Additionally, FindMPI sets the following variables for running MPI
# programs from the command line:
Convert builtin help to reStructuredText source files Run the convert-help.bash script to convert documentation: ./convert-help.bash "/path/to/CMake-build/bin" Then remove it.
2013-10-15 19:17:36 +04:00
#
# ::
#
# MPIEXEC Executable for running MPI programs
# MPIEXEC_NUMPROC_FLAG Flag to pass to MPIEXEC before giving
# it the number of processors to run on
# MPIEXEC_PREFLAGS Flags to pass to MPIEXEC directly
# before the executable to run.
# MPIEXEC_POSTFLAGS Flags to pass to MPIEXEC after other flags
#
FindMPI: Improve documentation formatting
2016-04-09 11:05:27 +03:00
# Usage
# ^^^^^
ENH: add new version of FindMPI, fix it to work with MPICH2 on windows
2008-03-08 03:58:29 +03:00
#
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# To use this module, simply call FindMPI from a CMakeLists.txt file, or
FindMPI: Improve documentation formatting
2016-04-09 11:05:27 +03:00
# run ``find_package(MPI)``, then run CMake. If you are happy with the
# auto-detected configuration for your language, then you're done. If
Convert builtin help to reStructuredText source files Run the convert-help.bash script to convert documentation: ./convert-help.bash "/path/to/CMake-build/bin" Then remove it.
2013-10-15 19:17:36 +04:00
# not, you have two options:
#
# ::
#
# 1. Set MPI_<lang>_COMPILER to the MPI wrapper (mpicc, etc.) of your
# choice and reconfigure. FindMPI will attempt to determine all the
# necessary variables using THAT compiler's compile and link flags.
# 2. If this fails, or if your MPI implementation does not come with
# a compiler wrapper, then set both MPI_<lang>_LIBRARIES and
# MPI_<lang>_INCLUDE_PATH. You may also set any other variables
# listed above, but these two are required. This will circumvent
# autodetection entirely.
#
FindMPI: Improve documentation formatting
2016-04-09 11:05:27 +03:00
# When configuration is successful, ``MPI_<lang>_COMPILER`` will be set to
# the compiler wrapper for <lang>, if it was found. ``MPI_<lang>_FOUND``
Convert builtin help to reStructuredText source files Run the convert-help.bash script to convert documentation: ./convert-help.bash "/path/to/CMake-build/bin" Then remove it.
2013-10-15 19:17:36 +04:00
# and other variables above will be set if any MPI implementation was
# found for <lang>, regardless of whether a compiler was found.
#
FindMPI: Improve documentation formatting
2016-04-09 11:05:27 +03:00
# When using ``MPIEXEC`` to execute MPI applications, you should typically
# use all of the ``MPIEXEC`` flags as follows:
Convert builtin help to reStructuredText source files Run the convert-help.bash script to convert documentation: ./convert-help.bash "/path/to/CMake-build/bin" Then remove it.
2013-10-15 19:17:36 +04:00
#
# ::
#
# ${MPIEXEC} ${MPIEXEC_NUMPROC_FLAG} PROCS
# ${MPIEXEC_PREFLAGS} EXECUTABLE ${MPIEXEC_POSTFLAGS} ARGS
#
FindMPI: Improve documentation formatting
2016-04-09 11:05:27 +03:00
# where ``PROCS`` is the number of processors on which to execute the
# program, ``EXECUTABLE`` is the MPI program, and ``ARGS`` are the arguments to
Convert builtin help to reStructuredText source files Run the convert-help.bash script to convert documentation: ./convert-help.bash "/path/to/CMake-build/bin" Then remove it.
2013-10-15 19:17:36 +04:00
# pass to the MPI program.
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
#
FindMPI: Improve documentation formatting
2016-04-09 11:05:27 +03:00
# Backward Compatibility
# ^^^^^^^^^^^^^^^^^^^^^^
FindMPI: Fix documentation formatting Adjust whitespace to make the output of "--help-module FindMPI" look good. Also separate the comment containing the copyright and license notice so it does not appear in the documentation.
2011-03-16 17:11:33 +03:00
#
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# For backward compatibility with older versions of FindMPI, these
# variables are set, but deprecated:
Convert builtin help to reStructuredText source files Run the convert-help.bash script to convert documentation: ./convert-help.bash "/path/to/CMake-build/bin" Then remove it.
2013-10-15 19:17:36 +04:00
#
# ::
#
# MPI_FOUND MPI_COMPILER MPI_LIBRARY
# MPI_COMPILE_FLAGS MPI_INCLUDE_PATH MPI_EXTRA_LIBRARY
# MPI_LINK_FLAGS MPI_LIBRARIES
#
FindMPI: Improve documentation formatting
2016-04-09 11:05:27 +03:00
# In new projects, please use the ``MPI_<lang>_XXX`` equivalents.
FindMPI: Fix documentation formatting Adjust whitespace to make the output of "--help-module FindMPI" look good. Also separate the comment containing the copyright and license notice so it does not appear in the documentation.
2011-03-16 17:11:33 +03:00
Convert CMake find-modules to BSD License This adds copyright/license notification blocks CMake's find-modules. Many of the modules had no notices at all. Some had notices referring to the BSD license already. This commit normalizes existing notices and adds missing notices.
2009-09-28 19:45:50 +04:00
#=============================================================================
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# Copyright 2001-2011 Kitware, Inc.
# Copyright 2010-2011 Todd Gamblin tgamblin@llnl.gov
# Copyright 2001-2009 Dave Partyka
Convert CMake find-modules to BSD License This adds copyright/license notification blocks CMake's find-modules. Many of the modules had no notices at all. Some had notices referring to the BSD license already. This commit normalizes existing notices and adds missing notices.
2009-09-28 19:45:50 +04:00
#
# Distributed under the OSI-approved BSD License (the "License");
# see accompanying file Copyright.txt for details.
#
# This software is distributed WITHOUT ANY WARRANTY; without even the
# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# See the License for more information.
#=============================================================================
Modules: Fix spelling 'To distributed' -> 'To distribute'
2010-08-07 04:48:47 +04:00
# (To distribute this file outside of CMake, substitute the full
Convert CMake find-modules to BSD License This adds copyright/license notification blocks CMake's find-modules. Many of the modules had no notices at all. Some had notices referring to the BSD license already. This commit normalizes existing notices and adds missing notices.
2009-09-28 19:45:50 +04:00
# License text for the above reference.)
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# include this to handle the QUIETLY and REQUIRED arguments
include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
ENH: Improvements in finding MPI on windows. ENH: reorganized searching mpi for mpi components (include,lib,bin) using a single set of search paths instead of seperately mainted lists of paths for each.
2009-10-27 19:43:50 +03:00
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
#
# This part detects MPI compilers, attempting to wade through the mess of compiler names in
# a sensible way.
#
# The compilers are detected in this order:
#
Fix spelling and typos (non-binary)
2012-11-07 20:13:09 +04:00
# 1. Try to find the most generic available MPI compiler, as this is usually set up by
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# cluster admins. e.g., if plain old mpicc is available, we'll use it and assume it's
# the right compiler.
#
# 2. If a generic mpicc is NOT found, then we attempt to find one that matches
# CMAKE_<lang>_COMPILER_ID. e.g. if you are using XL compilers, we'll try to find mpixlc
# and company, but not mpiicc. This hopefully prevents toolchain mismatches.
#
# If you want to force a particular MPI compiler other than what we autodetect (e.g. if you
# want to compile regular stuff with GNU and parallel stuff with Intel), you can always set
# your favorite MPI_<lang>_COMPILER explicitly and this stuff will be ignored.
#
# Start out with the generic MPI compiler names, as these are most commonly used.
set(_MPI_C_COMPILER_NAMES mpicc mpcc mpicc_r mpcc_r)
set(_MPI_CXX_COMPILER_NAMES mpicxx mpiCC mpcxx mpCC mpic++ mpc++
mpicxx_r mpiCC_r mpcxx_r mpCC_r mpic++_r mpc++_r)
set(_MPI_Fortran_COMPILER_NAMES mpif95 mpif95_r mpf95 mpf95_r
mpif90 mpif90_r mpf90 mpf90_r
mpif77 mpif77_r mpf77 mpf77_r)
# GNU compiler names
set(_MPI_GNU_C_COMPILER_NAMES mpigcc mpgcc mpigcc_r mpgcc_r)
set(_MPI_GNU_CXX_COMPILER_NAMES mpig++ mpg++ mpig++_r mpg++_r)
set(_MPI_GNU_Fortran_COMPILER_NAMES mpigfortran mpgfortran mpigfortran_r mpgfortran_r
mpig77 mpig77_r mpg77 mpg77_r)
# Intel MPI compiler names
set(_MPI_Intel_C_COMPILER_NAMES mpiicc)
set(_MPI_Intel_CXX_COMPILER_NAMES mpiicpc mpiicxx mpiic++ mpiiCC)
set(_MPI_Intel_Fortran_COMPILER_NAMES mpiifort mpiif95 mpiif90 mpiif77)
# PGI compiler names
set(_MPI_PGI_C_COMPILER_NAMES mpipgcc mppgcc)
set(_MPI_PGI_CXX_COMPILER_NAMES mpipgCC mppgCC)
set(_MPI_PGI_Fortran_COMPILER_NAMES mpipgf95 mpipgf90 mppgf95 mppgf90 mpipgf77 mppgf77)
# XLC MPI Compiler names
set(_MPI_XL_C_COMPILER_NAMES mpxlc mpxlc_r mpixlc mpixlc_r)
set(_MPI_XL_CXX_COMPILER_NAMES mpixlcxx mpixlC mpixlc++ mpxlcxx mpxlc++ mpixlc++ mpxlCC
mpixlcxx_r mpixlC_r mpixlc++_r mpxlcxx_r mpxlc++_r mpixlc++_r mpxlCC_r)
set(_MPI_XL_Fortran_COMPILER_NAMES mpixlf95 mpixlf95_r mpxlf95 mpxlf95_r
mpixlf90 mpixlf90_r mpxlf90 mpxlf90_r
mpixlf77 mpixlf77_r mpxlf77 mpxlf77_r
mpixlf mpixlf_r mpxlf mpxlf_r)
# append vendor-specific compilers to the list if we either don't know the compiler id,
# or if we know it matches the regular compiler.
foreach (lang C CXX Fortran)
foreach (id GNU Intel PGI XL)
Avoid if() quoted auto-dereference When testing CMAKE_<LANG>_COMPILER_ID values, do not explicitly dereference or quote the variable. We want if() to auto-dereference the variable and not its value. Also replace MATCHES with STREQUAL where equivalent.
2014-10-14 18:25:32 +04:00
if (NOT CMAKE_${lang}_COMPILER_ID OR CMAKE_${lang}_COMPILER_ID STREQUAL id)
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
list(APPEND _MPI_${lang}_COMPILER_NAMES ${_MPI_${id}_${lang}_COMPILER_NAMES})
endif()
unset(_MPI_${id}_${lang}_COMPILER_NAMES) # clean up the namespace here
endforeach()
endforeach()
# Names to try for MPI exec
set(_MPI_EXEC_NAMES mpiexec mpirun lamexec srun)
# Grab the path to MPI from the registry if we're on windows.
BUG: rename MPI_PACKAGE_DIR and MPI_PREFIX_PATH vars to be prefixed with _ to prevent conflicts with known variable names in other projects.
2009-11-13 18:57:01 +03:00
set(_MPI_PREFIX_PATH)
ENH: Improvements in finding MPI on windows. ENH: reorganized searching mpi for mpi components (include,lib,bin) using a single set of search paths instead of seperately mainted lists of paths for each.
2009-10-27 19:43:50 +03:00
if(WIN32)
FindMPI: add more search paths for MSMPI Also comment what the various search paths are for.
2015-01-06 20:58:07 +03:00
# MSMPI
FindMPI: handle trailing slash from $MSMPI_BIN When installing, MSMPI puts a trailing backslash in the MSMPI_BIN environment variable. This causes trouble when concatenating in CMake since the list separator is now escaped and no longer a list separator due to the trailing backslash. Instead, use file(TO_CMAKE_PATH) to make the path CMake-friendly.
2015-01-12 17:21:23 +03:00
file(TO_CMAKE_PATH "$ENV{MSMPI_BIN}" msmpi_bin_path) # The default path ends with a '\' and doesn't mix with ';' when appending.
list(APPEND _MPI_PREFIX_PATH "${msmpi_bin_path}")
unset(msmpi_bin_path)
FindMPI: search for msmpi's mpiexec as well
2014-12-12 01:26:06 +03:00
list(APPEND _MPI_PREFIX_PATH "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\MPI;InstallRoot]/Bin")
FindMPI: add more search paths for MSMPI Also comment what the various search paths are for.
2015-01-06 20:58:07 +03:00
list(APPEND _MPI_PREFIX_PATH "$ENV{MSMPI_INC}/..") # The SDK is installed separately from the runtime
# MPICH
BUG: rename MPI_PACKAGE_DIR and MPI_PREFIX_PATH vars to be prefixed with _ to prevent conflicts with known variable names in other projects.
2009-11-13 18:57:01 +03:00
list(APPEND _MPI_PREFIX_PATH "[HKEY_LOCAL_MACHINE\\SOFTWARE\\MPICH\\SMPD;binary]/..")
Add a new registry key to check for the location of MPICH2.
2010-03-11 18:42:07 +03:00
list(APPEND _MPI_PREFIX_PATH "[HKEY_LOCAL_MACHINE\\SOFTWARE\\MPICH2;Path]")
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
list(APPEND _MPI_PREFIX_PATH "$ENV{ProgramW6432}/MPICH2/")
ENH: Improvements in finding MPI on windows. ENH: reorganized searching mpi for mpi components (include,lib,bin) using a single set of search paths instead of seperately mainted lists of paths for each.
2009-10-27 19:43:50 +03:00
endif()
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# Build a list of prefixes to search for MPI.
ENH: Improvements in finding MPI on windows. ENH: reorganized searching mpi for mpi components (include,lib,bin) using a single set of search paths instead of seperately mainted lists of paths for each.
2009-10-27 19:43:50 +03:00
foreach(SystemPrefixDir ${CMAKE_SYSTEM_PREFIX_PATH})
BUG: rename MPI_PACKAGE_DIR and MPI_PREFIX_PATH vars to be prefixed with _ to prevent conflicts with known variable names in other projects.
2009-11-13 18:57:01 +03:00
foreach(MpiPackageDir ${_MPI_PREFIX_PATH})
ENH: Improvements in finding MPI on windows. ENH: reorganized searching mpi for mpi components (include,lib,bin) using a single set of search paths instead of seperately mainted lists of paths for each.
2009-10-27 19:43:50 +03:00
if(EXISTS ${SystemPrefixDir}/${MpiPackageDir})
BUG: rename MPI_PACKAGE_DIR and MPI_PREFIX_PATH vars to be prefixed with _ to prevent conflicts with known variable names in other projects.
2009-11-13 18:57:01 +03:00
list(APPEND _MPI_PREFIX_PATH "${SystemPrefixDir}/${MpiPackageDir}")
ENH: Improvements in finding MPI on windows. ENH: reorganized searching mpi for mpi components (include,lib,bin) using a single set of search paths instead of seperately mainted lists of paths for each.
2009-10-27 19:43:50 +03:00
endif()
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
endforeach()
endforeach()
FindMPI: Factor out compiler wrapper execution into helper
2014-12-04 21:51:00 +03:00
function (_mpi_check_compiler compiler options cmdvar resvar)
execute_process(
COMMAND "${compiler}" ${options}
OUTPUT_VARIABLE cmdline OUTPUT_STRIP_TRAILING_WHITESPACE
ERROR_VARIABLE cmdline ERROR_STRIP_TRAILING_WHITESPACE
RESULT_VARIABLE success)
FindMPI: Workaround Intel MPI 5.0.1 exit code problem (#15182) This MPI compiler may return zero even in some error cases. Check the output to catch such cases. Suggested-by: Kelly Thompson <kgt@lanl.gov>
2014-12-04 21:54:00 +03:00
# Intel MPI 5.0.1 will return a zero return code even when the
# argument to the MPI compiler wrapper is unknown. Attempt to
# catch this case.
FindMPI: Extend Intel-MPI 5+ workaround for recent GCCs Extend the workaround added by commit v3.2.0-rc1~278^2 (FindMPI: Workaround Intel MPI 5.0.1 exit code problem, 2014-12-04) with an additional/alternate keyword to recognize the case with recent GCCs.
2015-07-09 17:34:19 +03:00
if(cmdline MATCHES "undefined reference" OR cmdline MATCHES "unrecognized")
FindMPI: Workaround Intel MPI 5.0.1 exit code problem (#15182) This MPI compiler may return zero even in some error cases. Check the output to catch such cases. Suggested-by: Kelly Thompson <kgt@lanl.gov>
2014-12-04 21:54:00 +03:00
set(success 255 )
endif()
FindMPI: Factor out compiler wrapper execution into helper
2014-12-04 21:51:00 +03:00
set(${cmdvar} "${cmdline}" PARENT_SCOPE)
set(${resvar} "${success}" PARENT_SCOPE)
endfunction()
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
#
# interrogate_mpi_compiler(lang try_libs)
#
# Attempts to extract compiler and linker args from an MPI compiler. The arguments set
# by this function are:
#
# MPI_<lang>_INCLUDE_PATH MPI_<lang>_LINK_FLAGS MPI_<lang>_FOUND
# MPI_<lang>_COMPILE_FLAGS MPI_<lang>_LIBRARIES
#
# MPI_<lang>_COMPILER must be set beforehand to the absolute path to an MPI compiler for
# <lang>. Additionally, MPI_<lang>_INCLUDE_PATH and MPI_<lang>_LIBRARIES may be set
# to skip autodetection.
#
# If try_libs is TRUE, this will also attempt to find plain MPI libraries in the usual
# way. In general, this is not as effective as interrogating the compilers, as it
# ignores language-specific flags and libraries. However, some MPI implementations
# (Windows implementations) do not have compiler wrappers, so this approach must be used.
#
function (interrogate_mpi_compiler lang try_libs)
Try regular compiler when no MPI compiler. If FindMPI can't interrogate any of the available compilers, it attempts to compile simple MPI programs with CMAKE_${lang}_COMPILER. If this works, it uses that as MPI_${lang}_COMPILER. This allows MPI to be discovered on Cray XT/XE systems, where modules are used and cc, CC, and ftn compilers *are* MPI compilers.
2011-06-21 06:55:08 +04:00
# MPI_${lang}_NO_INTERROGATE will be set to a compiler name when the *regular* compiler was
# discovered to be the MPI compiler. This happens on machines like the Cray XE6 that use
# modules to set cc, CC, and ftn to the MPI compilers. If the user force-sets another MPI
# compiler, MPI_${lang}_COMPILER won't be equal to MPI_${lang}_NO_INTERROGATE, and we'll
# inspect that compiler anew. This allows users to set new compilers w/o rm'ing cache.
string(COMPARE NOTEQUAL "${MPI_${lang}_NO_INTERROGATE}" "${MPI_${lang}_COMPILER}" interrogate)
# If MPI is set already in the cache, don't bother with interrogating the compiler.
if (interrogate AND ((NOT MPI_${lang}_INCLUDE_PATH) OR (NOT MPI_${lang}_LIBRARIES)))
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
if (MPI_${lang}_COMPILER)
# Check whether the -showme:compile option works. This indicates that we have either OpenMPI
# or a newer version of LAM-MPI, and implies that -showme:link will also work.
FindMPI: Factor out compiler wrapper execution into helper
2014-12-04 21:51:00 +03:00
_mpi_check_compiler("${MPI_${lang}_COMPILER}" "-showme:compile" MPI_COMPILE_CMDLINE MPI_COMPILER_RETURN)
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
if (MPI_COMPILER_RETURN EQUAL 0)
# If we appear to have -showme:compile, then we should
# also have -showme:link. Try it.
execute_process(
COMMAND ${MPI_${lang}_COMPILER} -showme:link
OUTPUT_VARIABLE MPI_LINK_CMDLINE OUTPUT_STRIP_TRAILING_WHITESPACE
ERROR_VARIABLE MPI_LINK_CMDLINE ERROR_STRIP_TRAILING_WHITESPACE
RESULT_VARIABLE MPI_COMPILER_RETURN)
if (MPI_COMPILER_RETURN EQUAL 0)
# We probably have -showme:incdirs and -showme:libdirs as well,
# so grab that while we're at it.
execute_process(
COMMAND ${MPI_${lang}_COMPILER} -showme:incdirs
OUTPUT_VARIABLE MPI_INCDIRS OUTPUT_STRIP_TRAILING_WHITESPACE
ERROR_VARIABLE MPI_INCDIRS ERROR_STRIP_TRAILING_WHITESPACE)
execute_process(
COMMAND ${MPI_${lang}_COMPILER} -showme:libdirs
OUTPUT_VARIABLE MPI_LIBDIRS OUTPUT_STRIP_TRAILING_WHITESPACE
ERROR_VARIABLE MPI_LIBDIRS ERROR_STRIP_TRAILING_WHITESPACE)
else()
# reset things here if something went wrong.
set(MPI_COMPILE_CMDLINE)
set(MPI_LINK_CMDLINE)
endif()
endif ()
# Older versions of LAM-MPI have "-showme". Try to find that.
if (NOT MPI_COMPILER_RETURN EQUAL 0)
FindMPI: Factor out compiler wrapper execution into helper
2014-12-04 21:51:00 +03:00
_mpi_check_compiler("${MPI_${lang}_COMPILER}" "-showme" MPI_COMPILE_CMDLINE MPI_COMPILER_RETURN)
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
endif()
# MVAPICH uses -compile-info and -link-info. Try them.
if (NOT MPI_COMPILER_RETURN EQUAL 0)
FindMPI: Factor out compiler wrapper execution into helper
2014-12-04 21:51:00 +03:00
_mpi_check_compiler("${MPI_${lang}_COMPILER}" "-compile-info" MPI_COMPILE_CMDLINE MPI_COMPILER_RETURN)
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# If we have compile-info, also have link-info.
if (MPI_COMPILER_RETURN EQUAL 0)
execute_process(
COMMAND ${MPI_${lang}_COMPILER} -link-info
OUTPUT_VARIABLE MPI_LINK_CMDLINE OUTPUT_STRIP_TRAILING_WHITESPACE
ERROR_VARIABLE MPI_LINK_CMDLINE ERROR_STRIP_TRAILING_WHITESPACE
RESULT_VARIABLE MPI_COMPILER_RETURN)
endif()
# make sure we got compile and link. Reset vars if something's wrong.
if (NOT MPI_COMPILER_RETURN EQUAL 0)
set(MPI_COMPILE_CMDLINE)
set(MPI_LINK_CMDLINE)
endif()
endif()
# MPICH just uses "-show". Try it.
if (NOT MPI_COMPILER_RETURN EQUAL 0)
FindMPI: Factor out compiler wrapper execution into helper
2014-12-04 21:51:00 +03:00
_mpi_check_compiler("${MPI_${lang}_COMPILER}" "-show" MPI_COMPILE_CMDLINE MPI_COMPILER_RETURN)
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
endif()
if (MPI_COMPILER_RETURN EQUAL 0)
# We have our command lines, but we might need to copy MPI_COMPILE_CMDLINE
# into MPI_LINK_CMDLINE, if we didn't find the link line.
if (NOT MPI_LINK_CMDLINE)
set(MPI_LINK_CMDLINE ${MPI_COMPILE_CMDLINE})
endif()
else()
message(STATUS "Unable to determine MPI from MPI driver ${MPI_${lang}_COMPILER}")
set(MPI_COMPILE_CMDLINE)
set(MPI_LINK_CMDLINE)
endif()
# Here, we're done with the interrogation part, and we'll try to extract args we care
# about from what we learned from the compiler wrapper scripts.
# If interrogation came back with something, extract our variable from the MPI command line
if (MPI_COMPILE_CMDLINE OR MPI_LINK_CMDLINE)
# Extract compile flags from the compile command line.
string(REGEX MATCHALL "(^| )-[Df]([^\" ]+|\"[^\"]+\")" MPI_ALL_COMPILE_FLAGS "${MPI_COMPILE_CMDLINE}")
set(MPI_COMPILE_FLAGS_WORK)
foreach(FLAG ${MPI_ALL_COMPILE_FLAGS})
if (MPI_COMPILE_FLAGS_WORK)
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-28 01:41:13 +03:00
string(APPEND MPI_COMPILE_FLAGS_WORK " ${FLAG}")
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
else()
set(MPI_COMPILE_FLAGS_WORK ${FLAG})
endif()
endforeach()
# Extract include paths from compile command line
string(REGEX MATCHALL "(^| )-I([^\" ]+|\"[^\"]+\")" MPI_ALL_INCLUDE_PATHS "${MPI_COMPILE_CMDLINE}")
foreach(IPATH ${MPI_ALL_INCLUDE_PATHS})
string(REGEX REPLACE "^ ?-I" "" IPATH ${IPATH})
Replace string(REGEX REPLACE) with string(REPLACE) where possible The simple replacement is much faster.
2014-04-06 23:51:33 +04:00
string(REPLACE "//" "/" IPATH ${IPATH})
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
list(APPEND MPI_INCLUDE_PATH_WORK ${IPATH})
endforeach()
# try using showme:incdirs if extracting didn't work.
if (NOT MPI_INCLUDE_PATH_WORK)
set(MPI_INCLUDE_PATH_WORK ${MPI_INCDIRS})
separate_arguments(MPI_INCLUDE_PATH_WORK)
endif()
# If all else fails, just search for mpi.h in the normal include paths.
if (NOT MPI_INCLUDE_PATH_WORK)
set(MPI_HEADER_PATH "MPI_HEADER_PATH-NOTFOUND" CACHE FILEPATH "Cleared" FORCE)
find_path(MPI_HEADER_PATH mpi.h
HINTS ${_MPI_BASE_DIR} ${_MPI_PREFIX_PATH}
PATH_SUFFIXES include)
set(MPI_INCLUDE_PATH_WORK ${MPI_HEADER_PATH})
endif()
# Extract linker paths from the link command line
FindMPI: Recognize /LIBPATH for specification of linker paths. The Intel MPI wrappers use this form of -L to specify library locations.
2016-04-14 20:01:43 +03:00
string(REGEX MATCHALL "(^| |-Wl,)(-L|/LIBPATH:)([^\" ]+|\"[^\"]+\")" MPI_ALL_LINK_PATHS "${MPI_LINK_CMDLINE}")
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
set(MPI_LINK_PATH)
foreach(LPATH ${MPI_ALL_LINK_PATHS})
FindMPI: Recognize /LIBPATH for specification of linker paths. The Intel MPI wrappers use this form of -L to specify library locations.
2016-04-14 20:01:43 +03:00
string(REGEX REPLACE "^(| |-Wl,)(-L|/LIBPATH:)" "" LPATH ${LPATH})
Replace string(REGEX REPLACE) with string(REPLACE) where possible The simple replacement is much faster.
2014-04-06 23:51:33 +04:00
string(REPLACE "//" "/" LPATH ${LPATH})
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
list(APPEND MPI_LINK_PATH ${LPATH})
endforeach()
# try using showme:libdirs if extracting didn't work.
if (NOT MPI_LINK_PATH)
set(MPI_LINK_PATH ${MPI_LIBDIRS})
separate_arguments(MPI_LINK_PATH)
endif()
# Extract linker flags from the link command line
FindMPI: Extract -Xlinker options Extend the regex that mathces -Wl, linker options to match -Xlinker too. These are used by Intel MPI and perhaps others.
2014-12-09 13:52:33 +03:00
string(REGEX MATCHALL "(^| )(-Wl,|-Xlinker )([^\" ]+|\"[^\"]+\")" MPI_ALL_LINK_FLAGS "${MPI_LINK_CMDLINE}")
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
set(MPI_LINK_FLAGS_WORK)
foreach(FLAG ${MPI_ALL_LINK_FLAGS})
if (MPI_LINK_FLAGS_WORK)
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-28 01:41:13 +03:00
string(APPEND MPI_LINK_FLAGS_WORK " ${FLAG}")
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
else()
set(MPI_LINK_FLAGS_WORK ${FLAG})
endif()
endforeach()
# Extract the set of libraries to link against from the link command
# line
string(REGEX MATCHALL "(^| )-l([^\" ]+|\"[^\"]+\")" MPI_LIBNAMES "${MPI_LINK_CMDLINE}")
FindMPI: Recognize `.lib` file names for specification of link libraries The Intel MPI compiler wrappers link against static MPI libraries simply by listing the libraries (no `-l`).
2016-04-14 20:03:21 +03:00
if(WIN32)
# The intel wrappers on windows link against static versions of the MPI libraries.
# The static libraries are simply listed on the command line without -l.
# For instance: " icl ... impi.lib "
string(REGEX MATCHALL "(^| )([^\" ]+)\\.lib" tmp "${MPI_LINK_CMDLINE}")
list(APPEND MPI_LIBNAMES ${tmp})
endif()
FindMPI: Use compiler implicit link dirs for matching language (#14870) Update the logic added by commit 2f9ad7c6 (Fix FindMPI for the intel compiler on linux, 2012-03-20) to use the implicit link directories for the current ${lang} instead of hard-coding C or CXX which may not be enabled. This is necessary for Fortran-only projects.
2014-04-10 00:22:00 +04:00
Fix FindMPI for the intel compiler on linux by looking in implict directories. Use the CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES to look for libraries that are in the -showme output from mpi<lang> programs. This is because some libraries reported by -showme are found there, and FindMPI will fail if they are not found.
2012-03-20 23:18:53 +04:00
# add the compiler implicit directories because some compilers
# such as the intel compiler have libraries that show up
# in the showme list that can only be found in the implicit
FindMPI: Use compiler implicit link dirs for matching language (#14870) Update the logic added by commit 2f9ad7c6 (Fix FindMPI for the intel compiler on linux, 2012-03-20) to use the implicit link directories for the current ${lang} instead of hard-coding C or CXX which may not be enabled. This is necessary for Fortran-only projects.
2014-04-10 00:22:00 +04:00
# link directories of the compiler.
if (DEFINED CMAKE_${lang}_IMPLICIT_LINK_DIRECTORIES)
Use string(APPEND) in Modules Automate with: find Modules -type f -print0 | xargs -0 perl -i -0pe \ 's/set\(([a-zA-Z0-9_]+)(\s+)"\$\{\1\}([^"])/string(APPEND \1\2"\3/g'
2016-07-28 01:41:13 +03:00
string(APPEND MPI_LINK_PATH
";${CMAKE_${lang}_IMPLICIT_LINK_DIRECTORIES}")
Fix FindMPI for the intel compiler on linux by looking in implict directories. Use the CMAKE_<LANG>_IMPLICIT_LINK_DIRECTORIES to look for libraries that are in the -showme output from mpi<lang> programs. This is because some libraries reported by -showme are found there, and FindMPI will fail if they are not found.
2012-03-20 23:18:53 +04:00
endif ()
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# Determine full path names for all of the libraries that one needs
# to link against in an MPI program
foreach(LIB ${MPI_LIBNAMES})
string(REGEX REPLACE "^ ?-l" "" LIB ${LIB})
FindMPI: Recognize `.lib` file names for specification of link libraries The Intel MPI compiler wrappers link against static MPI libraries simply by listing the libraries (no `-l`).
2016-04-14 20:03:21 +03:00
if(WIN32)
string(REGEX REPLACE "\\.lib$" "" LIB ${LIB})
endif()
string(STRIP ${LIB} LIB)
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# MPI_LIB is cached by find_library, but we don't want that. Clear it first.
set(MPI_LIB "MPI_LIB-NOTFOUND" CACHE FILEPATH "Cleared" FORCE)
find_library(MPI_LIB NAMES ${LIB} HINTS ${MPI_LINK_PATH})
if (MPI_LIB)
list(APPEND MPI_LIBRARIES_WORK ${MPI_LIB})
elseif (NOT MPI_FIND_QUIETLY)
message(WARNING "Unable to find MPI library ${LIB}")
endif()
endforeach()
# Sanity check MPI_LIBRARIES to make sure there are enough libraries
list(LENGTH MPI_LIBRARIES_WORK MPI_NUMLIBS)
list(LENGTH MPI_LIBNAMES MPI_NUMLIBS_EXPECTED)
if (NOT MPI_NUMLIBS EQUAL MPI_NUMLIBS_EXPECTED)
set(MPI_LIBRARIES_WORK "MPI_${lang}_LIBRARIES-NOTFOUND")
endif()
endif()
elseif(try_libs)
# If we didn't have an MPI compiler script to interrogate, attempt to find everything
# with plain old find functions. This is nasty because MPI implementations have LOTS of
# different library names, so this section isn't going to be very generic. We need to
# make sure it works for MS MPI, though, since there are no compiler wrappers for that.
find_path(MPI_HEADER_PATH mpi.h
HINTS ${_MPI_BASE_DIR} ${_MPI_PREFIX_PATH}
PATH_SUFFIXES include Inc)
set(MPI_INCLUDE_PATH_WORK ${MPI_HEADER_PATH})
# Decide between 32-bit and 64-bit libraries for Microsoft's MPI
if("${CMAKE_SIZEOF_VOID_P}" EQUAL 8)
FindMPI: MSMPI changed the subdirectories it uses
2015-01-06 20:58:31 +03:00
set(MS_MPI_ARCH_DIR x64)
set(MS_MPI_ARCH_DIR2 amd64)
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
else()
FindMPI: MSMPI changed the subdirectories it uses
2015-01-06 20:58:31 +03:00
set(MS_MPI_ARCH_DIR x86)
set(MS_MPI_ARCH_DIR2 i386)
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
endif()
set(MPI_LIB "MPI_LIB-NOTFOUND" CACHE FILEPATH "Cleared" FORCE)
find_library(MPI_LIB
NAMES mpi mpich mpich2 msmpi
HINTS ${_MPI_BASE_DIR} ${_MPI_PREFIX_PATH}
FindMPI: MSMPI changed the subdirectories it uses
2015-01-06 20:58:31 +03:00
PATH_SUFFIXES lib lib/${MS_MPI_ARCH_DIR} Lib Lib/${MS_MPI_ARCH_DIR} Lib/${MS_MPI_ARCH_DIR2})
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
set(MPI_LIBRARIES_WORK ${MPI_LIB})
# Right now, we only know about the extra libs for C++.
# We could add Fortran here (as there is usually libfmpich, etc.), but
# this really only has to work with MS MPI on Windows.
# Assume that other MPI's are covered by the compiler wrappers.
if (${lang} STREQUAL CXX)
set(MPI_LIB "MPI_LIB-NOTFOUND" CACHE FILEPATH "Cleared" FORCE)
find_library(MPI_LIB
NAMES mpi++ mpicxx cxx mpi_cxx
HINTS ${_MPI_BASE_DIR} ${_MPI_PREFIX_PATH}
PATH_SUFFIXES lib)
if (MPI_LIBRARIES_WORK AND MPI_LIB)
FindMPI: Append MPI C++ library correctly in non-compiler case (#12874) When we have no MPI compiler wrapper and search explicitly for the MPI C++ library append it correctly to the list of libraries instead of using a space. Suggested-by: Mourad Boufarguine <bouffa@gmail.com>
2012-01-16 18:03:08 +04:00
list(APPEND MPI_LIBRARIES_WORK ${MPI_LIB})
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
endif()
endif()
if (NOT MPI_LIBRARIES_WORK)
set(MPI_LIBRARIES_WORK "MPI_${lang}_LIBRARIES-NOTFOUND")
endif()
endif()
# If we found MPI, set up all of the appropriate cache entries
set(MPI_${lang}_COMPILE_FLAGS ${MPI_COMPILE_FLAGS_WORK} CACHE STRING "MPI ${lang} compilation flags" FORCE)
set(MPI_${lang}_INCLUDE_PATH ${MPI_INCLUDE_PATH_WORK} CACHE STRING "MPI ${lang} include path" FORCE)
set(MPI_${lang}_LINK_FLAGS ${MPI_LINK_FLAGS_WORK} CACHE STRING "MPI ${lang} linking flags" FORCE)
set(MPI_${lang}_LIBRARIES ${MPI_LIBRARIES_WORK} CACHE STRING "MPI ${lang} libraries to link against" FORCE)
mark_as_advanced(MPI_${lang}_COMPILE_FLAGS MPI_${lang}_INCLUDE_PATH MPI_${lang}_LINK_FLAGS MPI_${lang}_LIBRARIES)
# clear out our temporary lib/header detectionv variable here.
set(MPI_LIB "MPI_LIB-NOTFOUND" CACHE INTERNAL "Scratch variable for MPI lib detection" FORCE)
set(MPI_HEADER_PATH "MPI_HEADER_PATH-NOTFOUND" CACHE INTERNAL "Scratch variable for MPI header detection" FORCE)
endif()
# finally set a found variable for each MPI language
if (MPI_${lang}_INCLUDE_PATH AND MPI_${lang}_LIBRARIES)
set(MPI_${lang}_FOUND TRUE PARENT_SCOPE)
else()
set(MPI_${lang}_FOUND FALSE PARENT_SCOPE)
endif()
endfunction()
Fix issues with removing try_compile input file. - Don't remove input file - Put output in ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY} - Remove try_compile variable from the cache after using
2011-06-22 01:02:01 +04:00
# This function attempts to compile with the regular compiler, to see if MPI programs
# work with it. This is a last ditch attempt after we've tried interrogating mpicc and
# friends, and after we've tried to find generic libraries. Works on machines like
# Cray XE6, where the modules environment changes what MPI version cc, CC, and ftn use.
Try regular compiler when no MPI compiler. If FindMPI can't interrogate any of the available compilers, it attempts to compile simple MPI programs with CMAKE_${lang}_COMPILER. If this works, it uses that as MPI_${lang}_COMPILER. This allows MPI to be discovered on Cray XT/XE systems, where modules are used and cc, CC, and ftn compilers *are* MPI compilers.
2011-06-21 06:55:08 +04:00
function(try_regular_compiler lang success)
Fix issues with removing try_compile input file. - Don't remove input file - Put output in ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY} - Remove try_compile variable from the cache after using
2011-06-22 01:02:01 +04:00
set(scratch_directory ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY})
Try regular compiler when no MPI compiler. If FindMPI can't interrogate any of the available compilers, it attempts to compile simple MPI programs with CMAKE_${lang}_COMPILER. If this works, it uses that as MPI_${lang}_COMPILER. This allows MPI to be discovered on Cray XT/XE systems, where modules are used and cc, CC, and ftn compilers *are* MPI compilers.
2011-06-21 06:55:08 +04:00
if (${lang} STREQUAL Fortran)
Fix issues with removing try_compile input file. - Don't remove input file - Put output in ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY} - Remove try_compile variable from the cache after using
2011-06-22 01:02:01 +04:00
set(test_file ${scratch_directory}/cmake_mpi_test.f90)
Try regular compiler when no MPI compiler. If FindMPI can't interrogate any of the available compilers, it attempts to compile simple MPI programs with CMAKE_${lang}_COMPILER. If this works, it uses that as MPI_${lang}_COMPILER. This allows MPI to be discovered on Cray XT/XE systems, where modules are used and cc, CC, and ftn compilers *are* MPI compilers.
2011-06-21 06:55:08 +04:00
file(WRITE ${test_file}
"program hello\n"
"include 'mpif.h'\n"
"integer ierror\n"
"call MPI_INIT(ierror)\n"
"call MPI_FINALIZE(ierror)\n"
"end\n")
else()
if (${lang} STREQUAL CXX)
Fix issues with removing try_compile input file. - Don't remove input file - Put output in ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY} - Remove try_compile variable from the cache after using
2011-06-22 01:02:01 +04:00
set(test_file ${scratch_directory}/cmake_mpi_test.cpp)
Try regular compiler when no MPI compiler. If FindMPI can't interrogate any of the available compilers, it attempts to compile simple MPI programs with CMAKE_${lang}_COMPILER. If this works, it uses that as MPI_${lang}_COMPILER. This allows MPI to be discovered on Cray XT/XE systems, where modules are used and cc, CC, and ftn compilers *are* MPI compilers.
2011-06-21 06:55:08 +04:00
else()
Fix issues with removing try_compile input file. - Don't remove input file - Put output in ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY} - Remove try_compile variable from the cache after using
2011-06-22 01:02:01 +04:00
set(test_file ${scratch_directory}/cmake_mpi_test.c)
Try regular compiler when no MPI compiler. If FindMPI can't interrogate any of the available compilers, it attempts to compile simple MPI programs with CMAKE_${lang}_COMPILER. If this works, it uses that as MPI_${lang}_COMPILER. This allows MPI to be discovered on Cray XT/XE systems, where modules are used and cc, CC, and ftn compilers *are* MPI compilers.
2011-06-21 06:55:08 +04:00
endif()
file(WRITE ${test_file}
"#include <mpi.h>\n"
"int main(int argc, char **argv) {\n"
" MPI_Init(&argc, &argv);\n"
" MPI_Finalize();\n"
"}\n")
endif()
Fix issues with removing try_compile input file. - Don't remove input file - Put output in ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY} - Remove try_compile variable from the cache after using
2011-06-22 01:02:01 +04:00
try_compile(compiler_has_mpi ${scratch_directory} ${test_file})
if (compiler_has_mpi)
Try regular compiler when no MPI compiler. If FindMPI can't interrogate any of the available compilers, it attempts to compile simple MPI programs with CMAKE_${lang}_COMPILER. If this works, it uses that as MPI_${lang}_COMPILER. This allows MPI to be discovered on Cray XT/XE systems, where modules are used and cc, CC, and ftn compilers *are* MPI compilers.
2011-06-21 06:55:08 +04:00
set(MPI_${lang}_NO_INTERROGATE ${CMAKE_${lang}_COMPILER} CACHE STRING "Whether to interrogate MPI ${lang} compiler" FORCE)
set(MPI_${lang}_COMPILER ${CMAKE_${lang}_COMPILER} CACHE STRING "MPI ${lang} compiler" FORCE)
set(MPI_${lang}_COMPILE_FLAGS "" CACHE STRING "MPI ${lang} compilation flags" FORCE)
set(MPI_${lang}_INCLUDE_PATH "" CACHE STRING "MPI ${lang} include path" FORCE)
set(MPI_${lang}_LINK_FLAGS "" CACHE STRING "MPI ${lang} linking flags" FORCE)
set(MPI_${lang}_LIBRARIES "" CACHE STRING "MPI ${lang} libraries to link against" FORCE)
endif()
Fix issues with removing try_compile input file. - Don't remove input file - Put output in ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY} - Remove try_compile variable from the cache after using
2011-06-22 01:02:01 +04:00
set(${success} ${compiler_has_mpi} PARENT_SCOPE)
unset(compiler_has_mpi CACHE)
Try regular compiler when no MPI compiler. If FindMPI can't interrogate any of the available compilers, it attempts to compile simple MPI programs with CMAKE_${lang}_COMPILER. If this works, it uses that as MPI_${lang}_COMPILER. This allows MPI to be discovered on Cray XT/XE systems, where modules are used and cc, CC, and ftn compilers *are* MPI compilers.
2011-06-21 06:55:08 +04:00
endfunction()
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# End definitions, commence real work here.
ENH: Improvements in finding MPI on windows. ENH: reorganized searching mpi for mpi components (include,lib,bin) using a single set of search paths instead of seperately mainted lists of paths for each.
2009-10-27 19:43:50 +03:00
# Most mpi distros have some form of mpiexec which gives us something we can reliably look for.
ENH: add new version of FindMPI, fix it to work with MPICH2 on windows
2008-03-08 03:58:29 +03:00
find_program(MPIEXEC
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
NAMES ${_MPI_EXEC_NAMES}
FindMPI: Honor MPI_HOME for MPIEXEC (#14347) We already use MPI_HOME and ENV{MPI_HOME} as hints for the location of the MPI compilers. Do the same for mpiexec, and then use the location of mpiexec as a hint to find the compilers.
2014-08-11 21:07:20 +04:00
HINTS ${MPI_HOME} $ENV{MPI_HOME}
BUG: rename MPI_PACKAGE_DIR and MPI_PREFIX_PATH vars to be prefixed with _ to prevent conflicts with known variable names in other projects.
2009-11-13 18:57:01 +03:00
PATHS ${_MPI_PREFIX_PATH}
ENH: Improvements in finding MPI on windows. ENH: reorganized searching mpi for mpi components (include,lib,bin) using a single set of search paths instead of seperately mainted lists of paths for each.
2009-10-27 19:43:50 +03:00
PATH_SUFFIXES bin
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
DOC "Executable for running MPI programs.")
ENH: Improvements in finding MPI on windows. ENH: reorganized searching mpi for mpi components (include,lib,bin) using a single set of search paths instead of seperately mainted lists of paths for each.
2009-10-27 19:43:50 +03:00
# call get_filename_component twice to remove mpiexec and the directory it exists in (typically bin).
# This gives us a fairly reliable base directory to search for /bin /lib and /include from.
BUG: fix MPI_BASE_DIR var to be called _MPI_BASE_DIR to prevent conflicts with known variable names in other projects.
2009-11-13 18:52:28 +03:00
get_filename_component(_MPI_BASE_DIR "${MPIEXEC}" PATH)
get_filename_component(_MPI_BASE_DIR "${_MPI_BASE_DIR}" PATH)
ENH: Improvements in finding MPI on windows. ENH: reorganized searching mpi for mpi components (include,lib,bin) using a single set of search paths instead of seperately mainted lists of paths for each.
2009-10-27 19:43:50 +03:00
ENH: Enhance FindMPI module by properly handling backward compatibility with the older module, adding documentation, and coping with multiple include and linker paths
2008-03-31 18:55:32 +04:00
set(MPIEXEC_NUMPROC_FLAG "-np" CACHE STRING "Flag used by MPI to specify the number of processes for MPIEXEC; the next option will be the number of processes.")
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
set(MPIEXEC_PREFLAGS "" CACHE STRING "These flags will be directly before the executable that is being run by MPIEXEC.")
set(MPIEXEC_POSTFLAGS "" CACHE STRING "These flags will come after all flags given to MPIEXEC.")
set(MPIEXEC_MAX_NUMPROCS "2" CACHE STRING "Maximum number of processors available to run MPI applications.")
mark_as_advanced(MPIEXEC MPIEXEC_NUMPROC_FLAG MPIEXEC_PREFLAGS MPIEXEC_POSTFLAGS MPIEXEC_MAX_NUMPROCS)
Added backward compatibility for input as well as output vars. Users can now supply MPI_COMPILER, MPI_INCLUDE_PATH, MPI_LIBRARY, and others as with the old FindMPI. These are mapped to their respective equivalents for C and CXX. Fortran is not touched, as there was no Fortran support in the old FindMPI.
2011-04-24 13:55:23 +04:00
#=============================================================================
# Backward compatibility input hacks. Propagate the FindMPI hints to C and
# CXX if the respective new versions are not defined. Translate the old
# MPI_LIBRARY and MPI_EXTRA_LIBRARY to respective MPI_${lang}_LIBRARIES.
#
# Once we find the new variables, we translate them back into their old
# equivalents below.
foreach (lang C CXX)
# Old input variables.
set(_MPI_OLD_INPUT_VARS COMPILER COMPILE_FLAGS INCLUDE_PATH LINK_FLAGS)
# Set new vars based on their old equivalents, if the new versions are not already set.
foreach (var ${_MPI_OLD_INPUT_VARS})
if (NOT MPI_${lang}_${var} AND MPI_${var})
set(MPI_${lang}_${var} "${MPI_${var}}")
endif()
endforeach()
# Special handling for MPI_LIBRARY and MPI_EXTRA_LIBRARY, which we nixed in the
# new FindMPI. These need to be merged into MPI_<lang>_LIBRARIES
if (NOT MPI_${lang}_LIBRARIES AND (MPI_LIBRARY OR MPI_EXTRA_LIBRARY))
set(MPI_${lang}_LIBRARIES ${MPI_LIBRARY} ${MPI_EXTRA_LIBRARY})
endif()
endforeach()
#=============================================================================
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# This loop finds the compilers and sends them off for interrogation.
foreach (lang C CXX Fortran)
if (CMAKE_${lang}_COMPILER_WORKS)
# If the user supplies a compiler *name* instead of an absolute path, assume that we need to find THAT compiler.
if (MPI_${lang}_COMPILER)
FindMPI: Drop unnecessary and incorrect use of GetPrerequisites Since commit v2.8.5~121^2~2 (FindMPI: Handle multiple languages, 2010-12-29) we called the GetPrerequisites is_file_executable function but passed the name of a CMake variable instead of its value. Therefore the function has always failed and caused the search for the compiler name to run even with an absolute path. Switch to using if(IS_ABSOLUTE) instead and drop use of GetPrerequisites.
2015-07-31 16:42:25 +03:00
if (NOT IS_ABSOLUTE "${MPI_${lang}_COMPILER}")
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# Get rid of our default list of names and just search for the name the user wants.
set(_MPI_${lang}_COMPILER_NAMES ${MPI_${lang}_COMPILER})
set(MPI_${lang}_COMPILER "MPI_${lang}_COMPILER-NOTFOUND" CACHE FILEPATH "Cleared" FORCE)
endif()
FindMPI: Drop unnecessary and incorrect use of GetPrerequisites Since commit v2.8.5~121^2~2 (FindMPI: Handle multiple languages, 2010-12-29) we called the GetPrerequisites is_file_executable function but passed the name of a CMake variable instead of its value. Therefore the function has always failed and caused the search for the compiler name to run even with an absolute path. Switch to using if(IS_ABSOLUTE) instead and drop use of GetPrerequisites.
2015-07-31 16:42:25 +03:00
# If the user specifies a compiler, we don't want to try to search libraries either.
set(try_libs FALSE)
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
else()
set(try_libs TRUE)
endif()
find_program(MPI_${lang}_COMPILER
NAMES ${_MPI_${lang}_COMPILER_NAMES}
FindMPI: Honor MPI_HOME for MPIEXEC (#14347) We already use MPI_HOME and ENV{MPI_HOME} as hints for the location of the MPI compilers. Do the same for mpiexec, and then use the location of mpiexec as a hint to find the compilers.
2014-08-11 21:07:20 +04:00
HINTS ${_MPI_BASE_DIR}/bin
PATHS ${_MPI_PREFIX_PATH}
)
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
interrogate_mpi_compiler(${lang} ${try_libs})
mark_as_advanced(MPI_${lang}_COMPILER)
Try regular compiler when no MPI compiler. If FindMPI can't interrogate any of the available compilers, it attempts to compile simple MPI programs with CMAKE_${lang}_COMPILER. If this works, it uses that as MPI_${lang}_COMPILER. This allows MPI to be discovered on Cray XT/XE systems, where modules are used and cc, CC, and ftn compilers *are* MPI compilers.
2011-06-21 06:55:08 +04:00
# last ditch try -- if nothing works so far, just try running the regular compiler and
# see if we can create an MPI executable.
set(regular_compiler_worked 0)
if (NOT MPI_${lang}_LIBRARIES OR NOT MPI_${lang}_INCLUDE_PATH)
try_regular_compiler(${lang} regular_compiler_worked)
endif()
FindMPI: Set correct variables for calls to FPHSA Since FPHSA is called for multiple compiler languages with "MPI_${lang}" rather than just "MPI", make sure variables for controlling QUIET, REQUIRED and VERSION are propagated with names prefixed by MPI_${lang} as well, rather than just MPI. The find_package call sets up the values of MPI_FIND_REQUIRED and friends, but these calls to FPHSA need MPI_${lang}_FIND_REQUIRED and friends in order to function as intended.
2012-09-27 08:41:28 +04:00
set(MPI_${lang}_FIND_QUIETLY ${MPI_FIND_QUIETLY})
set(MPI_${lang}_FIND_REQUIRED ${MPI_FIND_REQUIRED})
set(MPI_${lang}_FIND_VERSION ${MPI_FIND_VERSION})
set(MPI_${lang}_FIND_VERSION_EXACT ${MPI_FIND_VERSION_EXACT})
Try regular compiler when no MPI compiler. If FindMPI can't interrogate any of the available compilers, it attempts to compile simple MPI programs with CMAKE_${lang}_COMPILER. If this works, it uses that as MPI_${lang}_COMPILER. This allows MPI to be discovered on Cray XT/XE systems, where modules are used and cc, CC, and ftn compilers *are* MPI compilers.
2011-06-21 06:55:08 +04:00
if (regular_compiler_worked)
find_package_handle_standard_args(MPI_${lang} DEFAULT_MSG MPI_${lang}_COMPILER)
else()
find_package_handle_standard_args(MPI_${lang} DEFAULT_MSG MPI_${lang}_LIBRARIES MPI_${lang}_INCLUDE_PATH)
endif()
ENH: Improvements in finding MPI on windows. ENH: reorganized searching mpi for mpi components (include,lib,bin) using a single set of search paths instead of seperately mainted lists of paths for each.
2009-10-27 19:43:50 +03:00
endif()
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
endforeach()
Add MPICH2 and Microsoft HPC paths, add paths to find mpiexec. Now it works better automatically on Windows. Thanks to Dave Partyka for developing the patch.
2009-09-05 02:02:05 +04:00
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
#=============================================================================
Added backward compatibility for input as well as output vars. Users can now supply MPI_COMPILER, MPI_INCLUDE_PATH, MPI_LIBRARY, and others as with the old FindMPI. These are mapped to their respective equivalents for C and CXX. Fortran is not touched, as there was no Fortran support in the old FindMPI.
2011-04-24 13:55:23 +04:00
# More backward compatibility stuff
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
#
# Bare MPI sans ${lang} vars are set to CXX then C, depending on what was found.
# This mimics the behavior of the old language-oblivious FindMPI.
set(_MPI_OLD_VARS FOUND COMPILER INCLUDE_PATH COMPILE_FLAGS LINK_FLAGS LIBRARIES)
if (MPI_CXX_FOUND)
foreach (var ${_MPI_OLD_VARS})
set(MPI_${var} ${MPI_CXX_${var}})
endforeach()
elseif (MPI_C_FOUND)
foreach (var ${_MPI_OLD_VARS})
set(MPI_${var} ${MPI_C_${var}})
endforeach()
else()
# Note that we might still have found Fortran, but you'll need to use MPI_Fortran_FOUND
ENH: Enhance FindMPI module by properly handling backward compatibility with the older module, adding documentation, and coping with multiple include and linker paths
2008-03-31 18:55:32 +04:00
set(MPI_FOUND FALSE)
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
endif()
STYLE: use FIND_PACKAGE_HANDLE_STANDARD_ARGS() also in FindMPI.cmake -remove unnecessary ELSE() in FindThreads.cmake Alex
2007-08-06 19:02:58 +04:00
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# Chop MPI_LIBRARIES into the old-style MPI_LIBRARY and MPI_EXTRA_LIBRARY, and set them in cache.
if (MPI_LIBRARIES)
list(GET MPI_LIBRARIES 0 MPI_LIBRARY_WORK)
set(MPI_LIBRARY ${MPI_LIBRARY_WORK} CACHE FILEPATH "MPI library to link against" FORCE)
else()
set(MPI_LIBRARY "MPI_LIBRARY-NOTFOUND" CACHE FILEPATH "MPI library to link against" FORCE)
endif()
ENH: Enhance FindMPI module by properly handling backward compatibility with the older module, adding documentation, and coping with multiple include and linker paths
2008-03-31 18:55:32 +04:00
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
list(LENGTH MPI_LIBRARIES MPI_NUMLIBS)
if (MPI_NUMLIBS GREATER 1)
set(MPI_EXTRA_LIBRARY_WORK ${MPI_LIBRARIES})
list(REMOVE_AT MPI_EXTRA_LIBRARY_WORK 0)
set(MPI_EXTRA_LIBRARY ${MPI_EXTRA_LIBRARY_WORK} CACHE STRING "Extra MPI libraries to link against" FORCE)
else()
set(MPI_EXTRA_LIBRARY "MPI_EXTRA_LIBRARY-NOTFOUND" CACHE STRING "Extra MPI libraries to link against" FORCE)
endif()
#=============================================================================
ENH: Improvements in finding MPI on windows. ENH: reorganized searching mpi for mpi components (include,lib,bin) using a single set of search paths instead of seperately mainted lists of paths for each.
2009-10-27 19:43:50 +03:00
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
# unset these vars to cleanup namespace
unset(_MPI_OLD_VARS)
BUG: rename MPI_PACKAGE_DIR and MPI_PREFIX_PATH vars to be prefixed with _ to prevent conflicts with known variable names in other projects.
2009-11-13 18:57:01 +03:00
unset(_MPI_PREFIX_PATH)
BUG: fix MPI_BASE_DIR var to be called _MPI_BASE_DIR to prevent conflicts with known variable names in other projects.
2009-11-13 18:52:28 +03:00
unset(_MPI_BASE_DIR)
FindMPI: Handle multiple languages Adds support for: - MPI_<lang>_COMPILER and other useful variables for C, CXX, Fortran - Better compiler interrogation (handles mvapich) - Supports specifying an MPI compiler name directly on the command line without and absolute path, e.g.: cmake -D MPI_CXX_COMPILER=mpixlC - Better compiler name searching tries to match MPI compiler to regular CMAKE_<lang>_COMPILER_ID, if it's available. Gets rid of: - MPI_LIBRARY, MPI_EXTRA_LIBRARY cache variables. These and other old vars are still exported for backward compatibility, but they're not cached.
2010-12-30 03:06:24 +03:00
foreach (lang C CXX Fortran)
unset(_MPI_${lang}_COMPILER_NAMES)
endforeach()