385 lines
13 KiB
CMake
385 lines
13 KiB
CMake
###
|
|
#
|
|
# @copyright (c) 2009-2014 The University of Tennessee and The University
|
|
# of Tennessee Research Foundation.
|
|
# All rights reserved.
|
|
# @copyright (c) 2012-2016 Inria. All rights reserved.
|
|
# @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
|
|
#
|
|
###
|
|
#
|
|
# - Find BLAS EXTENDED for MORSE projects: find include dirs and libraries
|
|
#
|
|
# This module allows to find BLAS libraries by calling the official FindBLAS module
|
|
# and handles the creation of different library lists whether the user wishes to link
|
|
# with a sequential BLAS or a multihreaded (BLAS_SEQ_LIBRARIES and BLAS_PAR_LIBRARIES).
|
|
# BLAS is detected with a FindBLAS call then if the BLAS vendor is Intel10_64lp, ACML
|
|
# or IBMESSLMT then the module attempts to find the corresponding multithreaded libraries.
|
|
#
|
|
# The following variables have been added to manage links with sequential or multithreaded
|
|
# versions:
|
|
# BLAS_INCLUDE_DIRS - BLAS include directories
|
|
# BLAS_LIBRARY_DIRS - Link directories for BLAS libraries
|
|
# BLAS_SEQ_LIBRARIES - BLAS component libraries to be linked (sequential)
|
|
# BLAS_PAR_LIBRARIES - BLAS component libraries to be linked (multithreaded)
|
|
|
|
#=============================================================================
|
|
# Copyright 2012-2013 Inria
|
|
# Copyright 2012-2013 Emmanuel Agullo
|
|
# Copyright 2012-2013 Mathieu Faverge
|
|
# Copyright 2012 Cedric Castagnede
|
|
# Copyright 2013-2016 Florent Pruvost
|
|
#
|
|
# Distributed under the OSI-approved BSD License (the "License");
|
|
# see accompanying file MORSE-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.
|
|
#=============================================================================
|
|
# (To distribute this file outside of Morse, substitute the full
|
|
# License text for the above reference.)
|
|
|
|
# macro to factorize this call
|
|
include(CMakeFindDependencyMacro)
|
|
macro(find_package_blas)
|
|
if(BLASEXT_FIND_REQUIRED)
|
|
if(BLASEXT_FIND_QUIETLY)
|
|
find_dependency(BLAS REQUIRED QUIET)
|
|
else()
|
|
find_dependency(BLAS REQUIRED)
|
|
endif()
|
|
else()
|
|
if(BLASEXT_FIND_QUIETLY)
|
|
find_dependency(BLAS QUIET)
|
|
else()
|
|
find_dependency(BLAS)
|
|
endif()
|
|
endif()
|
|
endmacro()
|
|
|
|
# add a cache variable to let the user specify the BLAS vendor
|
|
set(BLA_VENDOR "" CACHE STRING "list of possible BLAS vendor:
|
|
Open, Eigen, Goto, ATLAS PhiPACK, CXML, DXML, SunPerf, SCSL, SGIMATH, IBMESSL, IBMESSLMT,
|
|
Intel10_32 (intel mkl v10 32 bit),
|
|
Intel10_64lp (intel mkl v10 64 bit, lp thread model, lp64 model),
|
|
Intel10_64lp_seq (intel mkl v10 64 bit, sequential code, lp64 model),
|
|
Intel( older versions of mkl 32 and 64 bit),
|
|
ACML, ACML_MP, ACML_GPU, Apple, NAS, Generic")
|
|
|
|
if(NOT BLASEXT_FIND_QUIETLY)
|
|
message(STATUS "In FindBLASEXT")
|
|
message(STATUS "If you want to force the use of one specific library, "
|
|
"\n please specify the BLAS vendor by setting -DBLA_VENDOR=blas_vendor_name"
|
|
"\n at cmake configure.")
|
|
message(STATUS "List of possible BLAS vendor: Goto, ATLAS PhiPACK, CXML, "
|
|
"\n DXML, SunPerf, SCSL, SGIMATH, IBMESSL, IBMESSLMT, Intel10_32 (intel mkl v10 32 bit),"
|
|
"\n Intel10_64lp (intel mkl v10 64 bit, lp thread model, lp64 model),"
|
|
"\n Intel10_64lp_seq (intel mkl v10 64 bit, sequential code, lp64 model),"
|
|
"\n Intel( older versions of mkl 32 and 64 bit),"
|
|
"\n ACML, ACML_MP, ACML_GPU, Apple, NAS, Generic")
|
|
endif()
|
|
|
|
if (NOT BLAS_FOUND)
|
|
# First try to detect two cases:
|
|
# 1: only SEQ libs are handled
|
|
# 2: both SEQ and PAR libs are handled
|
|
find_package_blas()
|
|
endif ()
|
|
|
|
# detect the cases where SEQ and PAR libs are handled
|
|
if(BLA_VENDOR STREQUAL "All" AND
|
|
(BLAS_mkl_core_LIBRARY OR BLAS_mkl_core_dll_LIBRARY)
|
|
)
|
|
set(BLA_VENDOR "Intel")
|
|
if(BLAS_mkl_intel_LIBRARY)
|
|
set(BLA_VENDOR "Intel10_32")
|
|
endif()
|
|
if(BLAS_mkl_intel_lp64_LIBRARY)
|
|
set(BLA_VENDOR "Intel10_64lp")
|
|
endif()
|
|
if(NOT BLASEXT_FIND_QUIETLY)
|
|
message(STATUS "A BLAS library has been found (${BLAS_LIBRARIES}) but we"
|
|
"\n have also potentially detected some multithreaded BLAS libraries from the MKL."
|
|
"\n We try to find both libraries lists (Sequential/Multithreaded).")
|
|
endif()
|
|
set(BLAS_FOUND "")
|
|
elseif(BLA_VENDOR STREQUAL "All" AND BLAS_acml_LIBRARY)
|
|
set(BLA_VENDOR "ACML")
|
|
if(NOT BLASEXT_FIND_QUIETLY)
|
|
message(STATUS "A BLAS library has been found (${BLAS_LIBRARIES}) but we"
|
|
"\n have also potentially detected some multithreaded BLAS libraries from the ACML."
|
|
"\n We try to find both libraries lists (Sequential/Multithreaded).")
|
|
endif()
|
|
set(BLAS_FOUND "")
|
|
elseif(BLA_VENDOR STREQUAL "All" AND BLAS_essl_LIBRARY)
|
|
set(BLA_VENDOR "IBMESSL")
|
|
if(NOT BLASEXT_FIND_QUIETLY)
|
|
message(STATUS "A BLAS library has been found (${BLAS_LIBRARIES}) but we"
|
|
"\n have also potentially detected some multithreaded BLAS libraries from the ESSL."
|
|
"\n We try to find both libraries lists (Sequential/Multithreaded).")
|
|
endif()
|
|
set(BLAS_FOUND "")
|
|
endif()
|
|
|
|
# Intel case
|
|
if(BLA_VENDOR MATCHES "Intel*")
|
|
|
|
###
|
|
# look for include path if the BLAS vendor is Intel
|
|
###
|
|
|
|
# gather system include paths
|
|
unset(_inc_env)
|
|
if(WIN32)
|
|
string(REPLACE ":" ";" _inc_env "$ENV{INCLUDE}")
|
|
else()
|
|
string(REPLACE ":" ";" _path_env "$ENV{INCLUDE}")
|
|
list(APPEND _inc_env "${_path_env}")
|
|
string(REPLACE ":" ";" _path_env "$ENV{C_INCLUDE_PATH}")
|
|
list(APPEND _inc_env "${_path_env}")
|
|
string(REPLACE ":" ";" _path_env "$ENV{CPATH}")
|
|
list(APPEND _inc_env "${_path_env}")
|
|
string(REPLACE ":" ";" _path_env "$ENV{INCLUDE_PATH}")
|
|
list(APPEND _inc_env "${_path_env}")
|
|
endif()
|
|
list(APPEND _inc_env "${CMAKE_PLATFORM_IMPLICIT_INCLUDE_DIRECTORIES}")
|
|
list(APPEND _inc_env "${CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES}")
|
|
set(ENV_MKLROOT "$ENV{MKLROOT}")
|
|
if (ENV_MKLROOT)
|
|
list(APPEND _inc_env "${ENV_MKLROOT}/include")
|
|
endif()
|
|
list(REMOVE_DUPLICATES _inc_env)
|
|
|
|
# find mkl.h inside known include paths
|
|
set(BLAS_mkl.h_INCLUDE_DIRS "BLAS_mkl.h_INCLUDE_DIRS-NOTFOUND")
|
|
if(BLAS_INCDIR)
|
|
set(BLAS_mkl.h_INCLUDE_DIRS "BLAS_mkl.h_INCLUDE_DIRS-NOTFOUND")
|
|
find_path(BLAS_mkl.h_INCLUDE_DIRS
|
|
NAMES mkl.h
|
|
HINTS ${BLAS_INCDIR})
|
|
else()
|
|
if(BLAS_DIR)
|
|
set(BLAS_mkl.h_INCLUDE_DIRS "BLAS_mkl.h_INCLUDE_DIRS-NOTFOUND")
|
|
find_path(BLAS_mkl.h_INCLUDE_DIRS
|
|
NAMES mkl.h
|
|
HINTS ${BLAS_DIR}
|
|
PATH_SUFFIXES include)
|
|
else()
|
|
set(BLAS_mkl.h_INCLUDE_DIRS "BLAS_mkl.h_INCLUDE_DIRS-NOTFOUND")
|
|
find_path(BLAS_mkl.h_INCLUDE_DIRS
|
|
NAMES mkl.h
|
|
HINTS ${_inc_env})
|
|
endif()
|
|
endif()
|
|
mark_as_advanced(BLAS_mkl.h_INCLUDE_DIRS)
|
|
## Print status if not found
|
|
## -------------------------
|
|
#if (NOT BLAS_mkl.h_INCLUDE_DIRS AND MORSE_VERBOSE)
|
|
# Print_Find_Header_Status(blas mkl.h)
|
|
#endif ()
|
|
set(BLAS_INCLUDE_DIRS "")
|
|
if(BLAS_mkl.h_INCLUDE_DIRS)
|
|
list(APPEND BLAS_INCLUDE_DIRS "${BLAS_mkl.h_INCLUDE_DIRS}" )
|
|
endif()
|
|
|
|
###
|
|
# look for libs
|
|
###
|
|
# if Intel 10 64 bit -> look for sequential and multithreaded versions
|
|
if(BLA_VENDOR MATCHES "Intel10_64lp*")
|
|
|
|
## look for the sequential version
|
|
set(BLA_VENDOR "Intel10_64lp_seq")
|
|
if(NOT BLASEXT_FIND_QUIETLY)
|
|
message(STATUS "Look for the sequential version Intel10_64lp_seq")
|
|
endif()
|
|
find_package_blas()
|
|
if(BLAS_FOUND)
|
|
set(BLAS_SEQ_LIBRARIES "${BLAS_LIBRARIES}")
|
|
else()
|
|
set(BLAS_SEQ_LIBRARIES "${BLAS_SEQ_LIBRARIES-NOTFOUND}")
|
|
endif()
|
|
|
|
## look for the multithreaded version
|
|
set(BLA_VENDOR "Intel10_64lp")
|
|
if(NOT BLASEXT_FIND_QUIETLY)
|
|
message(STATUS "Look for the multithreaded version Intel10_64lp")
|
|
endif()
|
|
find_package_blas()
|
|
if(BLAS_FOUND)
|
|
set(BLAS_PAR_LIBRARIES "${BLAS_LIBRARIES}")
|
|
else()
|
|
set(BLAS_PAR_LIBRARIES "${BLAS_PAR_LIBRARIES-NOTFOUND}")
|
|
endif()
|
|
|
|
else()
|
|
|
|
if(BLAS_FOUND)
|
|
set(BLAS_SEQ_LIBRARIES "${BLAS_LIBRARIES}")
|
|
else()
|
|
set(BLAS_SEQ_LIBRARIES "${BLAS_SEQ_LIBRARIES-NOTFOUND}")
|
|
endif()
|
|
|
|
endif()
|
|
|
|
# ACML case
|
|
elseif(BLA_VENDOR MATCHES "ACML*")
|
|
|
|
## look for the sequential version
|
|
set(BLA_VENDOR "ACML")
|
|
find_package_blas()
|
|
if(BLAS_FOUND)
|
|
set(BLAS_SEQ_LIBRARIES "${BLAS_LIBRARIES}")
|
|
else()
|
|
set(BLAS_SEQ_LIBRARIES "${BLAS_SEQ_LIBRARIES-NOTFOUND}")
|
|
endif()
|
|
|
|
## look for the multithreaded version
|
|
set(BLA_VENDOR "ACML_MP")
|
|
find_package_blas()
|
|
if(BLAS_FOUND)
|
|
set(BLAS_PAR_LIBRARIES "${BLAS_LIBRARIES}")
|
|
else()
|
|
set(BLAS_PAR_LIBRARIES "${BLAS_PAR_LIBRARIES-NOTFOUND}")
|
|
endif()
|
|
|
|
# IBMESSL case
|
|
elseif(BLA_VENDOR MATCHES "IBMESSL*")
|
|
|
|
## look for the sequential version
|
|
set(BLA_VENDOR "IBMESSL")
|
|
find_package_blas()
|
|
if(BLAS_FOUND)
|
|
set(BLAS_SEQ_LIBRARIES "${BLAS_LIBRARIES}")
|
|
else()
|
|
set(BLAS_SEQ_LIBRARIES "${BLAS_SEQ_LIBRARIES-NOTFOUND}")
|
|
endif()
|
|
|
|
## look for the multithreaded version
|
|
set(BLA_VENDOR "IBMESSLMT")
|
|
find_package_blas()
|
|
if(BLAS_FOUND)
|
|
set(BLAS_PAR_LIBRARIES "${BLAS_LIBRARIES}")
|
|
else()
|
|
set(BLAS_PAR_LIBRARIES "${BLAS_PAR_LIBRARIES-NOTFOUND}")
|
|
endif()
|
|
|
|
else()
|
|
|
|
if(BLAS_FOUND)
|
|
# define the SEQ libs as the BLAS_LIBRARIES
|
|
set(BLAS_SEQ_LIBRARIES "${BLAS_LIBRARIES}")
|
|
else()
|
|
set(BLAS_SEQ_LIBRARIES "${BLAS_SEQ_LIBRARIES-NOTFOUND}")
|
|
endif()
|
|
set(BLAS_PAR_LIBRARIES "${BLAS_PAR_LIBRARIES-NOTFOUND}")
|
|
|
|
endif()
|
|
|
|
|
|
if(BLAS_SEQ_LIBRARIES)
|
|
set(BLAS_LIBRARIES "${BLAS_SEQ_LIBRARIES}")
|
|
endif()
|
|
|
|
# extract libs paths
|
|
# remark: because it is not given by find_package(BLAS)
|
|
set(BLAS_LIBRARY_DIRS "")
|
|
string(REPLACE " " ";" BLAS_LIBRARIES "${BLAS_LIBRARIES}")
|
|
foreach(blas_lib ${BLAS_LIBRARIES})
|
|
if (EXISTS "${blas_lib}")
|
|
get_filename_component(a_blas_lib_dir "${blas_lib}" PATH)
|
|
list(APPEND BLAS_LIBRARY_DIRS "${a_blas_lib_dir}" )
|
|
else()
|
|
string(REPLACE "-L" "" blas_lib "${blas_lib}")
|
|
if (EXISTS "${blas_lib}")
|
|
list(APPEND BLAS_LIBRARY_DIRS "${blas_lib}" )
|
|
else()
|
|
get_filename_component(a_blas_lib_dir "${blas_lib}" PATH)
|
|
if (EXISTS "${a_blas_lib_dir}")
|
|
list(APPEND BLAS_LIBRARY_DIRS "${a_blas_lib_dir}" )
|
|
endif()
|
|
endif()
|
|
endif()
|
|
endforeach()
|
|
if (BLAS_LIBRARY_DIRS)
|
|
list(REMOVE_DUPLICATES BLAS_LIBRARY_DIRS)
|
|
endif ()
|
|
|
|
# check that BLAS has been found
|
|
# ---------------------------------
|
|
include(FindPackageHandleStandardArgs)
|
|
if(BLA_VENDOR MATCHES "Intel*")
|
|
if(BLA_VENDOR MATCHES "Intel10_64lp*")
|
|
if(NOT BLASEXT_FIND_QUIETLY)
|
|
message(STATUS "BLAS found is Intel MKL:"
|
|
"\n we manage two lists of libs, one sequential and one parallel if found"
|
|
"\n (see BLAS_SEQ_LIBRARIES and BLAS_PAR_LIBRARIES)")
|
|
message(STATUS "BLAS sequential libraries stored in BLAS_SEQ_LIBRARIES")
|
|
endif()
|
|
find_package_handle_standard_args(BLASEXT DEFAULT_MSG
|
|
BLAS_SEQ_LIBRARIES
|
|
BLAS_LIBRARY_DIRS
|
|
BLAS_INCLUDE_DIRS)
|
|
if(BLAS_PAR_LIBRARIES)
|
|
if(NOT BLASEXT_FIND_QUIETLY)
|
|
message(STATUS "BLAS parallel libraries stored in BLAS_PAR_LIBRARIES")
|
|
endif()
|
|
find_package_handle_standard_args(BLASEXT DEFAULT_MSG
|
|
BLAS_PAR_LIBRARIES)
|
|
endif()
|
|
else()
|
|
if(NOT BLASEXT_FIND_QUIETLY)
|
|
message(STATUS "BLAS sequential libraries stored in BLAS_SEQ_LIBRARIES")
|
|
endif()
|
|
find_package_handle_standard_args(BLASEXT DEFAULT_MSG
|
|
BLAS_SEQ_LIBRARIES
|
|
BLAS_LIBRARY_DIRS
|
|
BLAS_INCLUDE_DIRS)
|
|
endif()
|
|
elseif(BLA_VENDOR MATCHES "ACML*")
|
|
if(NOT BLASEXT_FIND_QUIETLY)
|
|
message(STATUS "BLAS found is ACML:"
|
|
"\n we manage two lists of libs, one sequential and one parallel if found"
|
|
"\n (see BLAS_SEQ_LIBRARIES and BLAS_PAR_LIBRARIES)")
|
|
message(STATUS "BLAS sequential libraries stored in BLAS_SEQ_LIBRARIES")
|
|
endif()
|
|
find_package_handle_standard_args(BLASEXT DEFAULT_MSG
|
|
BLAS_SEQ_LIBRARIES
|
|
BLAS_LIBRARY_DIRS)
|
|
if(BLAS_PAR_LIBRARIES)
|
|
if(NOT BLASEXT_FIND_QUIETLY)
|
|
message(STATUS "BLAS parallel libraries stored in BLAS_PAR_LIBRARIES")
|
|
endif()
|
|
find_package_handle_standard_args(BLASEXT DEFAULT_MSG
|
|
BLAS_PAR_LIBRARIES)
|
|
endif()
|
|
elseif(BLA_VENDOR MATCHES "IBMESSL*")
|
|
if(NOT BLASEXT_FIND_QUIETLY)
|
|
message(STATUS "BLAS found is ESSL:"
|
|
"\n we manage two lists of libs, one sequential and one parallel if found"
|
|
"\n (see BLAS_SEQ_LIBRARIES and BLAS_PAR_LIBRARIES)")
|
|
message(STATUS "BLAS sequential libraries stored in BLAS_SEQ_LIBRARIES")
|
|
endif()
|
|
find_package_handle_standard_args(BLASEXT DEFAULT_MSG
|
|
BLAS_SEQ_LIBRARIES
|
|
BLAS_LIBRARY_DIRS)
|
|
if(BLAS_PAR_LIBRARIES)
|
|
if(NOT BLASEXT_FIND_QUIETLY)
|
|
message(STATUS "BLAS parallel libraries stored in BLAS_PAR_LIBRARIES")
|
|
endif()
|
|
find_package_handle_standard_args(BLASEXT DEFAULT_MSG
|
|
BLAS_PAR_LIBRARIES)
|
|
endif()
|
|
else()
|
|
if(NOT BLASEXT_FIND_QUIETLY)
|
|
message(STATUS "BLAS sequential libraries stored in BLAS_SEQ_LIBRARIES")
|
|
endif()
|
|
find_package_handle_standard_args(BLASEXT DEFAULT_MSG
|
|
BLAS_SEQ_LIBRARIES
|
|
BLAS_LIBRARY_DIRS)
|
|
endif()
|
|
|
|
# Callers expect BLAS_FOUND to be set as well.
|
|
set(BLAS_FOUND BLASEXT_FOUND)
|