From 32c9a012f9b5e0c6e3252b352dc322b8f6130208 Mon Sep 17 00:00:00 2001 From: Maria Kraynyuk Date: Wed, 11 Sep 2024 13:46:30 -0700 Subject: [PATCH] [cmake] update MKLConfig to 2024.2.1 release (#568) --- cmake/mkl/MKLConfig.cmake | 434 ++++++++++++++++++++++--------- cmake/mkl/MKLConfigVersion.cmake | 6 +- 2 files changed, 319 insertions(+), 121 deletions(-) diff --git a/cmake/mkl/MKLConfig.cmake b/cmake/mkl/MKLConfig.cmake index 7614288b3..1b7ac5deb 100644 --- a/cmake/mkl/MKLConfig.cmake +++ b/cmake/mkl/MKLConfig.cmake @@ -19,7 +19,7 @@ #=================================================================== # CMake Config file for Intel(R) oneAPI Math Kernel Library (oneMKL) -#=============================================================================== +#=================================================================== #=============================================================================== # Input parameters @@ -30,12 +30,13 @@ # MKL_ROOT: oneMKL root directory (May be required for non-standard install locations. Optional otherwise.) # Default: use location from MKLROOT environment variable or /../../../ if MKLROOT is not defined # MKL_ARCH -# Values: ia32 intel64 +# Values: ia32 [ia32 support is deprecated] +# intel64 # Default: intel64 # MKL_LINK # Values: static, dynamic, sdl # Default: dynamic -# Exceptions:- DPC++ doesn't support sdl +# Exceptions:- SYCL doesn't support sdl # MKL_THREADING # Values: sequential, # intel_thread (Intel OpenMP), @@ -43,7 +44,7 @@ # pgi_thread (PGI OpenMP) [PGI support is deprecated], # tbb_thread # Default: intel_thread -# Exceptions:- DPC++ defaults to oneTBB, PGI compiler on Windows defaults to pgi_thread +# Exceptions:- SYCL defaults to oneTBB, PGI compiler on Windows defaults to pgi_thread # MKL_INTERFACE (for MKL_ARCH=intel64 only) # Values: lp64, ilp64 # GNU or INTEL interface will be selected based on Compiler. @@ -54,13 +55,13 @@ #----------------------------------- # Special options (OFF by default) #----------------------------------- -# ENABLE_BLAS95: Enables BLAS Fortran95 API -# ENABLE_LAPACK95: Enables LAPACK Fortran95 API -# ENABLE_BLACS: Enables cluster BLAS library -# ENABLE_CDFT: Enables cluster DFT library -# ENABLE_CPARDISO: Enables cluster PARDISO functionality -# ENABLE_SCALAPACK: Enables cluster LAPACK library -# ENABLE_OMP_OFFLOAD: Enables OpenMP Offload functionality +# ENABLE_BLAS95: Enables BLAS Fortran95 API in MKL::MKL +# ENABLE_LAPACK95: Enables LAPACK Fortran95 API in MKL::MKL +# ENABLE_BLACS: Enables cluster BLAS library in MKL::MKL +# ENABLE_CDFT: Enables cluster DFT library in MKL::MKL +# ENABLE_SCALAPACK: Enables cluster LAPACK library in MKL::MKL +# ENABLE_OMP_OFFLOAD: Enables OpenMP Offload functionality in MKL::MKL +# ENABLE_TRY_SYCL_COMPILE: Enables compiling a test program that calls a oneMKL DPC++ API # #================== # Output parameters @@ -75,7 +76,7 @@ # Provides all environment variables based on input parameters. # Currently useful for mkl_rt linking and BLACS on Windows. # Must be set as an ENVIRONMENT property. -# Example: +# Example: # add_test(NAME mytest COMMAND myexe) # if(MKL_ENV) # set_tests_properties(mytest PROPERTIES ENVIRONMENT "${MKL_ENV}") @@ -88,12 +89,23 @@ # # Below INTERFACE targets provide full link-lines for direct use. # Example: -# target_link_options( PUBLIC $) +# target_link_options( PUBLIC MKL::MKL) # # MKL::MKL # Link line for C and Fortran API # MKL::MKL_SYCL -# Link line for DPC++ API +# Link line for SYCL API +# MKL::MKL_SYCL:: +# Link line for specific domain SYCL API +# Where could be: BLAS, LAPACK, DFT, SPARSE, RNG, STATS, VM, DATA_FITTING (experimental) +# MKL::MKL_CDFT +# Link line for CDFT and Cluster FFTW API (includes MKL::MKL and MKL::MKL_BLACS) +# !IMPORTANT!: Because of specific link order it must not be used together +# with any other oneMKL targets in case of MKL_LINK=static on Linux +# MKL::MKL_SCALAPACK +# Link line for ScaLAPACK and PBLAS API (includes MKL::MKL and MKL::MKL_BLACS) +# MKL::MKL_BLACS +# Link line for BLACS and CPARDISO API (includes MKL::MKL) # # Note: For Device API, library linking is not required. # Compile options can be added from the INTERFACE_COMPILE_OPTIONS property on MKL::MKL_SYCL @@ -105,7 +117,7 @@ include_guard() -if(NOT MKL_LIBRARIES) +if(NOT TARGET MKL::MKL) function(mkl_message MSG_MODE MSG_TEXT) if(MSG_MODE STREQUAL "FATAL_ERROR") @@ -117,8 +129,14 @@ function(mkl_message MSG_MODE MSG_TEXT) endif() endfunction() +macro(mkl_not_found_and_return NOT_FOUND_MSG) + set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "${NOT_FOUND_MSG}") + set(${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) + return() +endmacro() + if(CMAKE_VERSION VERSION_LESS "3.13") - mkl_message(FATAL_ERROR "The minimum supported CMake version is 3.13. You are running version ${CMAKE_VERSION}.") + mkl_not_found_and_return("The minimum supported CMake version is 3.13. You are running version ${CMAKE_VERSION}.") endif() # Set CMake policies for well-defined behavior across CMake versions @@ -135,16 +153,16 @@ foreach(lang ${languages}) endforeach() list(REMOVE_DUPLICATES CURR_LANGS) -option(ENABLE_BLAS95 "Enables BLAS Fortran95 API" OFF) -option(ENABLE_LAPACK95 "Enables LAPACK Fortran95 API" OFF) -option(ENABLE_BLACS "Enables cluster BLAS library" OFF) -option(ENABLE_CDFT "Enables cluster DFT library" OFF) -option(ENABLE_CPARDISO "Enables cluster PARDISO functionality" OFF) -option(ENABLE_SCALAPACK "Enables cluster LAPACK library" OFF) -option(ENABLE_OMP_OFFLOAD "Enables OpenMP Offload functionality" OFF) +option(ENABLE_BLAS95 "Enables BLAS Fortran95 API" OFF) +option(ENABLE_LAPACK95 "Enables LAPACK Fortran95 API" OFF) +option(ENABLE_BLACS "Enables cluster BLAS library" OFF) +option(ENABLE_CDFT "Enables cluster DFT library" OFF) +option(ENABLE_SCALAPACK "Enables cluster LAPACK library" OFF) +option(ENABLE_OMP_OFFLOAD "Enables OpenMP Offload functionality" OFF) +option(ENABLE_TRY_SYCL_COMPILE "Enables compiling a oneMKL DPC++ test program" OFF) # Use MPI if any of these are enabled -if(ENABLE_BLACS OR ENABLE_CDFT OR ENABLE_SCALAPACK OR ENABLE_CPARDISO) +if(ENABLE_BLACS OR ENABLE_CDFT OR ENABLE_SCALAPACK) set(USE_MPI ON) endif() @@ -170,7 +188,8 @@ function(define_param TARGET_PARAM DEFAULT_PARAM SUPPORTED_LIST) set(STR_LIST "${STR_LIST} ${opt}") endforeach() if(${ARGC} EQUAL 3) - mkl_message(FATAL_ERROR "Invalid ${TARGET_PARAM} `${${TARGET_PARAM}}`, options are: ${STR_LIST}") + mkl_message(WARNING "Invalid ${TARGET_PARAM} `${${TARGET_PARAM}}`, options are: ${STR_LIST}") + set(${TARGET_PARAM} "${${TARGET_PARAM}}_MKL_INVALID_PARAM" PARENT_SCOPE) elseif(${ARGC} EQUAL 4) mkl_message(${ARGV3} "Invalid ${TARGET_PARAM} `${${TARGET_PARAM}}`, options are: ${STR_LIST}") set(${TARGET_PARAM} "" PARENT_SCOPE) @@ -186,9 +205,10 @@ endfunction() macro(check_required_vars) foreach(var IN ITEMS ${ARGV}) if(NOT ${var}) - set(${CMAKE_FIND_PACKAGE_NAME}_NOT_FOUND_MESSAGE "The required variable ${var} has an invalid value \"${${var}}\".") - set(${CMAKE_FIND_PACKAGE_NAME}_FOUND FALSE) - return() + mkl_not_found_and_return("The required variable ${var} has an invalid value \"${${var}}\".") + elseif(${${var}} MATCHES "_MKL_INVALID_PARAM$") + string(REPLACE "_MKL_INVALID_PARAM" "" INVALID_PARAM ${${var}}) + mkl_not_found_and_return("The required variable ${var} has an invalid value \"${INVALID_PARAM}\".") endif() endforeach() endmacro() @@ -267,6 +287,8 @@ endif() #================ # Extensions +set(SO_VER "2") +set(SYCL_SO_VER "4") if(UNIX) set(LIB_PREFIX "lib") set(LIB_EXT ".a") @@ -307,9 +329,9 @@ if(NOT DEFINED MKL_ROOT) set(MKL_ROOT_UPDATE_VERSION ${CMAKE_MATCH_1}) set(MKL_ROOT_VERSION ${MKL_ROOT_MAJOR_VERSION}.${MKL_ROOT_UPDATE_VERSION}) if(NOT MKL_ROOT_VERSION VERSION_EQUAL ${CMAKE_FIND_PACKAGE_NAME}_VERSION) - mkl_message(FATAL_ERROR "oneMKL ${MKL_ROOT_VERSION} specified by the environment variable MKLROOT \ - mismatches the found version ${${CMAKE_FIND_PACKAGE_NAME}_VERSION} \ - indicated by ${CMAKE_CURRENT_LIST_DIR}/MKLConfigVersion.cmake") + mkl_not_found_and_return("oneMKL ${MKL_ROOT_VERSION} specified by the environment variable MKLROOT \ + mismatches the found version ${${CMAKE_FIND_PACKAGE_NAME}_VERSION} \ + indicated by ${CMAKE_CURRENT_LIST_DIR}/MKLConfigVersion.cmake") endif() else() get_filename_component(MKL_CMAKE_PATH "${CMAKE_CURRENT_LIST_DIR}" REALPATH) @@ -344,6 +366,7 @@ define_param(MKL_ARCH DEFAULT_MKL_ARCH MKL_ARCH_LIST) check_required_vars(MKL_ARCH) if(MKL_ARCH STREQUAL "ia32") set(MKL_ARCH_DIR "32") + mkl_message(WARNING "ia32 support is deprecated and will be removed in the oneMKL 2025.0 release.") else() set(MKL_ARCH_DIR "") endif() @@ -376,7 +399,7 @@ if(SYCL_COMPILER) set(MKL_SYCL_INTERFACE_FULL intel_${MKL_INTERFACE}) endif() set(DEFAULT_MKL_SYCL_INTERFACE intel_ilp64) - set(MKL_SYCL_INTERFACE_LIST intel_ilp64) + set(MKL_SYCL_INTERFACE_LIST intel_lp64 intel_ilp64) define_param(MKL_SYCL_INTERFACE_FULL DEFAULT_MKL_SYCL_INTERFACE MKL_SYCL_INTERFACE_LIST STATUS) if(NOT MKL_SYCL_INTERFACE_FULL) set(SYCL_COMPILER OFF) @@ -404,15 +427,15 @@ else() set(MKL_INTERFACE_FULL intel) endif() else() - mkl_message(FATAL_ERROR "OSX does not support MKL_ARCH ia32.") + mkl_not_found_and_return("OSX does not support MKL_ARCH ia32.") endif() endif() +check_required_vars(MKL_INTERFACE_FULL) if(MKL_INTERFACE_FULL MATCHES "ilp64") set(MKL_INTERFACE "ilp64") else() set(MKL_INTERFACE "lp64") endif() -check_required_vars(MKL_INTERFACE_FULL) # Define oneMKL headers find_path(MKL_INCLUDE mkl.h @@ -474,7 +497,7 @@ define_param(MKL_THREADING DEFAULT_MKL_THREADING MKL_THREADING_LIST) check_required_vars(MKL_THREADING) # Define MKL_MPI -if(USE_MPI) +if(NOT MKL_LINK STREQUAL "sdl" AND NOT MKL_ARCH STREQUAL "ia32") set(DEFAULT_MKL_MPI intelmpi) if(UNIX) if(APPLE) @@ -494,6 +517,8 @@ if(USE_MPI) set(MKL_MPI msmpi) endif() check_required_vars(MKL_MPI) +else() + mkl_message(STATUS "MKL_MPI: Selected configuration is not supported by oneMKL cluster components") endif() # Provides a list of IMPORTED targets for the project @@ -521,6 +546,9 @@ set(MKL_ENV "") # Exported environment variables # Modify PATH variable to make it CMake-friendly set(OLD_PATH $ENV{PATH}) string(REPLACE ";" "\;" OLD_PATH "${OLD_PATH}") +# Modify LIBRARY_PATH variable to make it CMake-friendly +set(ENV_LIBRARY_PATH $ENV{LIBRARY_PATH}) +string(REPLACE ":" ";" ENV_LIBRARY_PATH "${ENV_LIBRARY_PATH}") # Compiler options if(GNU_C_COMPILER OR GNU_Fortran_COMPILER) @@ -552,17 +580,13 @@ endif() # For OpenMP Offload if(ENABLE_OMP_OFFLOAD) if(WIN32) - if(OPENMP_VERSION VERSION_GREATER_EQUAL "5.1") - if("Fortran" IN_LIST CURR_LANGS) - list(APPEND MKL_OFFLOAD_COPT -Qiopenmp -Qopenmp-targets:spir64 -DONEMKL_USE_OPENMP_VERSION=202011) - else() - list(APPEND MKL_OFFLOAD_COPT -Qiopenmp -Qopenmp-targets:spir64 -Qopenmp-version:51 -DONEMKL_USE_OPENMP_VERSION=202011) - endif() - else() + if("Fortran" IN_LIST CURR_LANGS) list(APPEND MKL_OFFLOAD_COPT -Qiopenmp -Qopenmp-targets:spir64) + else() + list(APPEND MKL_OFFLOAD_COPT -Qiopenmp -Qopenmp-targets:spir64 -Qopenmp-version:51) endif() - # -MD and -MDd are manually added here because offload functionality uses DPC++ runtime. - if(CMAKE_BUILD_TYPE MATCHES "Debug|DebInfo") + # -MD and -MDd are manually added here because offload functionality uses SYCL runtime. + if(CMAKE_BUILD_TYPE MATCHES "Debug") list(APPEND MKL_OFFLOAD_COPT -MDd) else() list(APPEND MKL_OFFLOAD_COPT -MD) @@ -570,14 +594,10 @@ if(ENABLE_OMP_OFFLOAD) list(APPEND MKL_OFFLOAD_LOPT -Qiopenmp -Qopenmp-targets:spir64 -fsycl) set(SKIP_LIBPATH ON) else() - if(OPENMP_VERSION VERSION_GREATER_EQUAL "5.1") - if("Fortran" IN_LIST CURR_LANGS) - list(APPEND MKL_OFFLOAD_COPT -fiopenmp -fopenmp-targets=spir64 -DONEMKL_USE_OPENMP_VERSION=202011) - else() - list(APPEND MKL_OFFLOAD_COPT -fiopenmp -fopenmp-targets=spir64 -fopenmp-version=51 -DONEMKL_USE_OPENMP_VERSION=202011) - endif() - else () + if("Fortran" IN_LIST CURR_LANGS) list(APPEND MKL_OFFLOAD_COPT -fiopenmp -fopenmp-targets=spir64) + else() + list(APPEND MKL_OFFLOAD_COPT -fiopenmp -fopenmp-targets=spir64 -fopenmp-version=51) endif() list(APPEND MKL_OFFLOAD_LOPT -fiopenmp -fopenmp-targets=spir64 -fsycl) if(APPLE) @@ -590,7 +610,11 @@ endif() # For selected Interface if(SYCL_COMPILER) - list(INSERT MKL_SYCL_COPT 0 "-DMKL_ILP64") + if(MKL_INTERFACE STREQUAL "ilp64") + list(INSERT MKL_SYCL_COPT 0 "-DMKL_ILP64") + else() + mkl_message(STATUS "Experimental oneMKL Data Fitting SYCL API does not support LP64 on CPU") + endif() endif() if(MKL_INTERFACE_FULL) @@ -634,7 +658,7 @@ endif() # MKL_INTERFACE_FULL # All oneMKL Libraries if(SYCL_COMPILER) set(MKL_SYCL_IFACE_LIB mkl_${MKL_SYCL_INTERFACE_FULL}) - if(WIN32 AND CMAKE_BUILD_TYPE MATCHES "Debug|DebInfo" AND MKL_SYCL_THREADING STREQUAL "tbb_thread") + if(WIN32 AND CMAKE_BUILD_TYPE MATCHES "Debug" AND MKL_SYCL_THREADING STREQUAL "tbb_thread") set(MKL_SYCL_THREAD mkl_tbb_threadd) else() set(MKL_SYCL_THREAD mkl_${MKL_SYCL_THREADING}) @@ -651,14 +675,14 @@ list(APPEND MKL_SYCL_LIBS mkl_sycl_rng) list(APPEND MKL_SYCL_LIBS mkl_sycl_stats) list(APPEND MKL_SYCL_LIBS mkl_sycl_vm) if(NOT MKL_LINK STREQUAL "static") - if(WIN32 AND CMAKE_BUILD_TYPE MATCHES "Debug|DebInfo") + if(WIN32 AND CMAKE_BUILD_TYPE MATCHES "Debug") list(TRANSFORM MKL_SYCL_LIBS APPEND "d") endif() list(APPEND MKL_SYCL ${MKL_SYCL_LIBS}) # List for tracking incomplete onemKL package set(MISSED_MKL_SYCL_LIBS) else() - if(WIN32 AND CMAKE_BUILD_TYPE MATCHES "Debug|DebInfo") + if(WIN32 AND CMAKE_BUILD_TYPE MATCHES "Debug") set(MKL_SYCL mkl_sycld) else() set(MKL_SYCL mkl_sycl) @@ -667,7 +691,7 @@ endif() set(MKL_IFACE_LIB mkl_${MKL_INTERFACE_FULL}) set(MKL_CORE mkl_core) -if(WIN32 AND CMAKE_BUILD_TYPE MATCHES "Debug|DebInfo" AND MKL_THREADING STREQUAL "tbb_thread") +if(WIN32 AND CMAKE_BUILD_TYPE MATCHES "Debug" AND MKL_THREADING STREQUAL "tbb_thread") set(MKL_THREAD mkl_tbb_threadd) else() set(MKL_THREAD mkl_${MKL_THREADING}) @@ -750,9 +774,11 @@ if(ENABLE_LAPACK95) list(APPEND MKL_LIBRARIES ${MKL_LAPACK95}) list(APPEND MKL_LINK_LINE MKL::${MKL_LAPACK95}) endif() -if(ENABLE_SCALAPACK) +if(NOT MKL_LINK STREQUAL "sdl" AND NOT MKL_ARCH STREQUAL "ia32") list(APPEND MKL_LIBRARIES ${MKL_SCALAPACK}) - list(APPEND MKL_LINK_LINE MKL::${MKL_SCALAPACK}) + if(ENABLE_SCALAPACK) + list(APPEND MKL_LINK_LINE MKL::${MKL_SCALAPACK}) + endif() endif() if(ENABLE_OMP_OFFLOAD AND NOT MKL_LINK STREQUAL "sdl") list(APPEND MKL_LIBRARIES ${MKL_SYCL}) @@ -760,9 +786,11 @@ if(ENABLE_OMP_OFFLOAD AND NOT MKL_LINK STREQUAL "sdl") list(APPEND MKL_LINK_LINE ${MKL_SYCL_T}) endif() list(APPEND MKL_LINK_LINE ${START_GROUP}) -if(ENABLE_CDFT) +if(NOT MKL_LINK STREQUAL "sdl" AND NOT MKL_ARCH STREQUAL "ia32") list(APPEND MKL_LIBRARIES ${MKL_CDFT}) - list(APPEND MKL_LINK_LINE MKL::${MKL_CDFT}) + if(ENABLE_CDFT) + list(APPEND MKL_LINK_LINE MKL::${MKL_CDFT}) + endif() endif() if(MKL_LINK STREQUAL "sdl") list(APPEND MKL_LIBRARIES ${MKL_SDL}) @@ -771,9 +799,11 @@ else() list(APPEND MKL_LIBRARIES ${MKL_IFACE_LIB} ${MKL_THREAD} ${MKL_CORE}) list(APPEND MKL_LINK_LINE MKL::${MKL_IFACE_LIB} MKL::${MKL_THREAD} MKL::${MKL_CORE}) endif() -if(USE_MPI) +if(NOT MKL_LINK STREQUAL "sdl" AND NOT MKL_ARCH STREQUAL "ia32") list(APPEND MKL_LIBRARIES ${MKL_BLACS}) - list(APPEND MKL_LINK_LINE MKL::${MKL_BLACS}) + if(USE_MPI) + list(APPEND MKL_LINK_LINE MKL::${MKL_BLACS}) + endif() endif() list(APPEND MKL_LINK_LINE ${END_GROUP}) @@ -795,7 +825,10 @@ foreach(lib ${MKL_REQUESTED_LIBRARIES}) NO_DEFAULT_PATH) add_library(MKL::${lib} STATIC IMPORTED) else() - find_library(${lib}_file NAMES ${LIB_PREFIX}${lib}${DLL_EXT} ${lib} + find_library(${lib}_file NAMES ${LIB_PREFIX}${lib}${DLL_EXT} + ${LIB_PREFIX}${lib}${DLL_EXT}.${SO_VER} + ${LIB_PREFIX}${lib}${DLL_EXT}.${SYCL_SO_VER} + ${lib} PATHS ${MKL_ROOT} PATH_SUFFIXES "lib${MKL_ARCH_DIR}" NO_DEFAULT_PATH) @@ -805,14 +838,27 @@ foreach(lib ${MKL_REQUESTED_LIBRARIES}) list(APPEND MISSED_MKL_SYCL_LIBS ${lib}) set(MKL_SYCL_DOMAIN "") string(REGEX REPLACE "mkl_sycl_" "" MKL_SYCL_DOMAIN ${lib}) - if(WIN32 AND CMAKE_BUILD_TYPE MATCHES "Debug|DebInfo") + if(WIN32 AND CMAKE_BUILD_TYPE MATCHES "Debug") string(REGEX REPLACE "d$" "" MKL_SYCL_DOMAIN ${MKL_SYCL_DOMAIN}) endif() string(TOUPPER ${MKL_SYCL_DOMAIN} MKL_SYCL_DOMAIN) mkl_message(WARNING "Could NOT find MKL ${lib} for target MKL::MKL_SYCL::${MKL_SYCL_DOMAIN}") else() - check_required_vars(${lib}_file) - mkl_message(STATUS "Found ${${lib}_file}") + if(NOT USE_MPI AND (${lib} MATCHES "mkl_scalapack" OR ${lib} MATCHES "mkl_blacs" OR ${lib} MATCHES "mkl_cdft") + AND ${${lib}_file} STREQUAL "${lib}_file-NOTFOUND") + if(${lib} MATCHES "mkl_scalapack") + mkl_message(STATUS "Could NOT find MKL ${lib} for target MKL::MKL_SCALAPACK") + endif() + if(${lib} MATCHES "mkl_cdft") + mkl_message(STATUS "Could NOT find MKL ${lib} for target MKL::MKL_CDFT") + endif() + if(${lib} MATCHES "mkl_blacs") + mkl_message(STATUS "Could NOT find MKL ${lib} for targets MKL::MKL_SCALAPACK, MKL::MKL_CDFT, and MKL::MKL_BLACS") + endif() + else() + check_required_vars(${lib}_file) + mkl_message(STATUS "Found ${${lib}_file}") + endif() endif() # CMP0111, implemented in CMake 3.20+ requires a shared library target on Windows # to be defined with IMPLIB and LOCATION property. @@ -844,10 +890,13 @@ foreach(lib ${MKL_REQUESTED_LIBRARIES}) if(${lib} MATCHES "mkl_sycl" AND ${${lib}_file} STREQUAL "${lib}_file-NOTFOUND") mkl_message(WARNING "Could NOT find ${MKL_DLL_GLOB} for target MKL::MKL_SYCL::${MKL_SYCL_DOMAIN}") else() - mkl_message(FATAL_ERROR "${MKL_DLL_GLOB} not found") + mkl_not_found_and_return("${MKL_DLL_GLOB} not found") endif() endif() endif() + if(NOT DEFINED MKL_DLL_DIR AND MKL_DLL_FILE) + get_filename_component(MKL_DLL_DIR ${MKL_DLL_FILE} DIRECTORY) + endif() else() set_target_properties(MKL::${lib} PROPERTIES IMPORTED_LOCATION "${${lib}_file}") endif() @@ -902,6 +951,10 @@ if(MKL_THREADING STREQUAL "tbb_thread" OR MKL_SYCL_THREADING STREQUAL "tbb_threa list(APPEND MKL_SUPP_LINK -lc++) else() list(APPEND MKL_SUPP_LINK -lstdc++) + # force clang to link libstdc++ + if(CMAKE_C_COMPILER_ID STREQUAL "Clang") + list(APPEND MKL_SUPP_LINK -stdlib=libstdc++ ) + endif() endif() endif() if(MKL_SYCL_THREADING STREQUAL "tbb_thread") @@ -934,7 +987,7 @@ if(NOT MKL_THREADING STREQUAL "tbb_thread" AND MKL_THREADING MATCHES "_thread") set(OMP_LIBNAME ${LIB_PREFIX}${MKL_OMP_LIB}${LIB_EXT}) find_library(OMP_LIBRARY ${OMP_LIBNAME} - HINTS $ENV{LIB} $ENV{LIBRARY_PATH} $ENV{MKLROOT} ${MKL_ROOT} $ENV{CMPLR_ROOT} + HINTS $ENV{LIB} ${ENV_LIBRARY_PATH} $ENV{MKLROOT} ${MKL_ROOT} $ENV{CMPLR_ROOT} PATH_SUFFIXES "lib" "lib/${MKL_ARCH}" "lib/${MKL_ARCH}_lin" "lib/${MKL_ARCH}_win" "linux/compiler/lib/${MKL_ARCH}" @@ -943,6 +996,7 @@ if(NOT MKL_THREADING STREQUAL "tbb_thread" AND MKL_THREADING MATCHES "_thread") "windows/compiler/lib/${MKL_ARCH}_win" "../compiler/lib/${MKL_ARCH}_lin" "../compiler/lib/${MKL_ARCH}_win" "../compiler/lib/${MKL_ARCH}" "../compiler/lib" "compiler/lib" + "../../compiler/latest/lib" "../../compiler/latest/linux/compiler/lib/${MKL_ARCH}" "../../compiler/latest/linux/compiler/lib/${MKL_ARCH}_lin" "../../compiler/latest/windows/compiler/lib/${MKL_ARCH}" @@ -952,12 +1006,13 @@ if(NOT MKL_THREADING STREQUAL "tbb_thread" AND MKL_THREADING MATCHES "_thread") if(WIN32) set(OMP_DLLNAME ${LIB_PREFIX}${MKL_OMP_LIB}.dll) find_path(OMP_DLL_DIR ${OMP_DLLNAME} - HINTS $ENV{LIB} $ENV{LIBRARY_PATH} $ENV{MKLROOT} ${MKL_ROOT} $ENV{CMPLR_ROOT} + HINTS $ENV{LIB} ${ENV_LIBRARY_PATH} $ENV{MKLROOT} ${MKL_ROOT} $ENV{CMPLR_ROOT} PATH_SUFFIXES "bin" # Legacy layout support for oneMKL "redist/${MKL_ARCH}" "redist/${MKL_ARCH}_win" "redist/${MKL_ARCH}_win/compiler" "../redist/${MKL_ARCH}/compiler" "../compiler/lib" + "../../compiler/latest/bin" "../../compiler/latest/windows/redist/${MKL_ARCH}_win" "../../compiler/latest/windows/redist/${MKL_ARCH}_win/compiler" "../../compiler/latest/windows/compiler/redist/${MKL_ARCH}_win" @@ -997,53 +1052,20 @@ if(UNIX) endif() if(SYCL_COMPILER OR ENABLE_OMP_OFFLOAD) - if(WIN32) - # Detect sycl library version - if(NOT DEFINED SYCL_LIB_VER_CACHE) - set(SYCL_LIB_VER "") - find_library(SYCL_LIB_DIR ${LIB_PREFIX}sycl${LIB_EXT} - HINTS $ENV{LIB} $ENV{CMPLR_ROOT} - PATH_SUFFIXES "windows/lib" "../lib${MKL_ARCH_DIR}") - if(NOT SYCL_LIB_DIR) - foreach(ver RANGE 6 99) - find_library(SYCL_LIB_DIR ${LIB_PREFIX}sycl${ver}${LIB_EXT} - HINTS $ENV{LIB} $ENV{CMPLR_ROOT} - PATH_SUFFIXES "windows/lib" "../lib${MKL_ARCH_DIR}") - if(SYCL_LIB_DIR) - set(SYCL_LIB_VER ${ver}) - break() - endif() - endforeach() - endif() - set(SYCL_LIB_VER_CACHE ${SYCL_LIB_VER} CACHE STRING "") - endif() - - if(SYCL_COMPILER) - if(CMAKE_BUILD_TYPE MATCHES "Debug|DebInfo") - list(APPEND MKL_SYCL_SUPP_LINK ${LINK_PREFIX}sycl${SYCL_LIB_VER_CACHE}d${LINK_SUFFIX}) - else() - list(APPEND MKL_SYCL_SUPP_LINK ${LINK_PREFIX}sycl${SYCL_LIB_VER_CACHE}${LINK_SUFFIX}) - endif() - endif() - if(ENABLE_OMP_OFFLOAD) - if(CMAKE_BUILD_TYPE MATCHES "Debug|DebInfo") - list(APPEND MKL_SUPP_LINK ${LINK_PREFIX}sycl${SYCL_LIB_VER_CACHE}d${LINK_SUFFIX}) - else() - list(APPEND MKL_SUPP_LINK ${LINK_PREFIX}sycl${SYCL_LIB_VER_CACHE}${LINK_SUFFIX}) - endif() - endif() - else() - if(SYCL_COMPILER) + if(SYCL_COMPILER) + if(WIN32 AND CMAKE_BUILD_TYPE MATCHES "Debug") + list(APPEND MKL_SYCL_SUPP_LINK ${LINK_PREFIX}sycld${LINK_SUFFIX}) + else() list(APPEND MKL_SYCL_SUPP_LINK ${LINK_PREFIX}sycl${LINK_SUFFIX}) endif() - if(ENABLE_OMP_OFFLOAD) - list(APPEND MKL_SUPP_LINK ${LINK_PREFIX}sycl${LINK_SUFFIX}) - endif() - endif() - if(SYCL_COMPILER) list(APPEND MKL_SYCL_SUPP_LINK ${LINK_PREFIX}OpenCL${LINK_SUFFIX}) endif() if(ENABLE_OMP_OFFLOAD) + if(WIN32 AND CMAKE_BUILD_TYPE MATCHES "Debug") + list(APPEND MKL_SUPP_LINK ${LINK_PREFIX}sycld${LINK_SUFFIX}) + else() + list(APPEND MKL_SUPP_LINK ${LINK_PREFIX}sycl${LINK_SUFFIX}) + endif() list(APPEND MKL_SUPP_LINK ${LINK_PREFIX}OpenCL${LINK_SUFFIX}) endif() endif() @@ -1073,15 +1095,15 @@ if(SYCL_COMPILER) foreach(lib ${MKL_SYCL_LIBS}) set(MKL_SYCL_DOMAIN "") string(REGEX REPLACE "mkl_sycl_" "" MKL_SYCL_DOMAIN ${lib}) - if(WIN32 AND CMAKE_BUILD_TYPE MATCHES "Debug|DebInfo") + if(WIN32 AND CMAKE_BUILD_TYPE MATCHES "Debug") string(REGEX REPLACE "d$" "" MKL_SYCL_DOMAIN ${MKL_SYCL_DOMAIN}) endif() string(TOUPPER ${MKL_SYCL_DOMAIN} MKL_SYCL_DOMAIN) add_library(MKL::MKL_SYCL::${MKL_SYCL_DOMAIN} INTERFACE IMPORTED GLOBAL) add_dependencies(MKL::MKL_SYCL::${MKL_SYCL_DOMAIN} MKL_SYCL_MESSAGE) + target_compile_options(MKL::MKL_SYCL::${MKL_SYCL_DOMAIN} INTERFACE $<$:${MKL_SYCL_COPT}>) # Only dynamic link has domain specific libraries # Domain specific targets still use mkl_sycl for static - # STREQUAL "${lib}_file-NOTFOUND" if(MKL_LINK STREQUAL "static") target_link_libraries(MKL::MKL_SYCL::${MKL_SYCL_DOMAIN} INTERFACE ${MKL_SYCL_LINK_LINE} ${MKL_SYCL_THREAD_LIB} ${MKL_SYCL_SUPP_LINK}) else() @@ -1098,13 +1120,56 @@ if(NOT TARGET MKL::MKL) add_library(MKL::MKL INTERFACE IMPORTED GLOBAL) endif() target_compile_options(MKL::MKL INTERFACE - $<$,C>:${MKL_C_COPT}> - $<$,Fortran>:${MKL_F_COPT}> - $<$,CXX>:${MKL_CXX_COPT}> + $<$:${MKL_C_COPT}> + $<$:${MKL_F_COPT}> + $<$:${MKL_CXX_COPT}> $,${MKL_OFFLOAD_COPT},>) target_link_libraries(MKL::MKL INTERFACE ${MKL_LINK_LINE} ${MKL_THREAD_LIB} ${MKL_SUPP_LINK}) list(APPEND LINK_TYPES MKL::MKL) +# Define cluster components +if(NOT ${${MKL_CDFT}_file} STREQUAL "${MKL_CDFT}_file-NOTFOUND") + if(NOT TARGET MKL::MKL_BLACS) + add_library(MKL::MKL_BLACS INTERFACE IMPORTED GLOBAL) + endif() + if(MKL_LINK STREQUAL "static") + # Static link requires duplications for cross library dependency resolutions + target_link_libraries(MKL::MKL_BLACS INTERFACE ${${MKL_IFACE_LIB}_file} ${${MKL_THREAD}_file} ${${MKL_CORE}_file} ${${MKL_BLACS}_file}) + target_link_libraries(MKL::MKL_BLACS INTERFACE ${${MKL_IFACE_LIB}_file} ${${MKL_THREAD}_file} ${${MKL_CORE}_file} ${${MKL_BLACS}_file}) + target_link_libraries(MKL::MKL_BLACS INTERFACE MKL::MKL) + else() + target_link_libraries(MKL::MKL_BLACS INTERFACE MKL::MKL MKL::${MKL_BLACS}) + endif() +endif() +if(NOT ${${MKL_CDFT}_file} STREQUAL "${MKL_CDFT}_file-NOTFOUND" + AND NOT ${${MKL_BLACS}_file} STREQUAL "${MKL_BLACS}_file-NOTFOUND") + if(NOT TARGET MKL::MKL_CDFT) + add_library(MKL::MKL_CDFT INTERFACE IMPORTED GLOBAL) + endif() + if(UNIX AND NOT APPLE AND MKL_LINK STREQUAL "static") + # Static link requires duplications for cross library dependency resolutions + target_link_libraries(MKL::MKL_CDFT INTERFACE ${${MKL_CDFT}_file} ${${MKL_IFACE_LIB}_file} ${${MKL_THREAD}_file} ${${MKL_CORE}_file} ${${MKL_BLACS}_file}) + target_link_libraries(MKL::MKL_CDFT INTERFACE ${${MKL_CDFT}_file} ${${MKL_IFACE_LIB}_file} ${${MKL_THREAD}_file} ${${MKL_CORE}_file} ${${MKL_BLACS}_file}) + target_link_libraries(MKL::MKL_CDFT INTERFACE MKL::MKL) + else() + target_link_libraries(MKL::MKL_CDFT INTERFACE MKL::${MKL_CDFT} MKL::MKL_BLACS) + endif() +endif() +if(NOT ${${MKL_SCALAPACK}_file} STREQUAL "${MKL_SCALAPACK}_file-NOTFOUND" + AND NOT ${${MKL_BLACS}_file} STREQUAL "${MKL_BLACS}_file-NOTFOUND") + if(NOT TARGET MKL::MKL_SCALAPACK) + add_library(MKL::MKL_SCALAPACK INTERFACE IMPORTED GLOBAL) + endif() + if(UNIX AND NOT APPLE AND MKL_LINK STREQUAL "static") + # Static link requires duplications for cross library dependency resolutions + target_link_libraries(MKL::MKL_SCALAPACK INTERFACE ${${MKL_SCALAPACK}_file} ${${MKL_IFACE_LIB}_file} ${${MKL_THREAD}_file} ${${MKL_CORE}_file} ${${MKL_BLACS}_file}) + target_link_libraries(MKL::MKL_SCALAPACK INTERFACE ${${MKL_SCALAPACK}_file} ${${MKL_IFACE_LIB}_file} ${${MKL_THREAD}_file} ${${MKL_CORE}_file} ${${MKL_BLACS}_file}) + target_link_libraries(MKL::MKL_SCALAPACK INTERFACE MKL::MKL) + else() + target_link_libraries(MKL::MKL_SCALAPACK INTERFACE MKL::${MKL_SCALAPACK} MKL::MKL_BLACS) + endif() +endif() + foreach(link ${LINK_TYPES}) # Set properties on all INTERFACE targets target_include_directories(${link} BEFORE INTERFACE "${MKL_INCLUDE}") @@ -1142,7 +1207,6 @@ endif() # Add oneMKL dynamic libraries to PATH on Windows if(WIN32 AND NOT MKL_LINK STREQUAL "static") - get_filename_component(MKL_DLL_DIR ${MKL_DLL_FILE} DIRECTORY) set(MKL_ENV_PATH "${MKL_DLL_DIR}\;${MKL_ENV_PATH}") endif() @@ -1153,6 +1217,140 @@ if(MKL_ENV_PATH) endif() endif() +# Additional checks +if(ENABLE_TRY_SYCL_COMPILE AND "CXX" IN_LIST CURR_LANGS AND SYCL_COMPILER AND MKL_SYCL_LIBS) + # The check is run only once with the result cached + include(CheckCXXSourceCompiles) + set(CMAKE_REQUIRED_LIBRARIES MKL::MKL_SYCL) + foreach(lib IN LISTS MKL_SYCL_LIBS) + if(lib STREQUAL "mkl_sycl_blas") + check_cxx_source_compiles(" + #include + #include \"oneapi/mkl/blas.hpp\" + + int main() + { + sycl::queue q; + float x[1], res[1]; + oneapi::mkl::blas::asum(q, 1, x, 1, res); + return 0; + } + " MKL_TRY_SYCL_COMPILE) + break() + elseif(lib STREQUAL "mkl_sycl_lapack") + check_cxx_source_compiles(" + #include + #include \"oneapi/mkl/lapack.hpp\" + + int main() + { + sycl::queue q; + float a[1], scratchpad[1]; + std::int64_t ipiv[1]; + oneapi::mkl::lapack::getrf(q, 1, 1, a, 1, ipiv, scratchpad, 1); + return 0; + } + " MKL_TRY_SYCL_COMPILE) + break() + elseif(lib STREQUAL "mkl_sycl_dft") + check_cxx_source_compiles(" + #include + #include \"oneapi/mkl/dfti.hpp\" + + int main() + { + namespace dft = oneapi::mkl::dft; + dft::descriptor desc(1); + sycl::queue q; + desc.commit(q); + return 0; + } + " MKL_TRY_SYCL_COMPILE) + break() + elseif(lib STREQUAL "mkl_sycl_sparse") + check_cxx_source_compiles(" + #include + #include \"oneapi/mkl/spblas.hpp\" + + int main() + { + sycl::queue q; + oneapi::mkl::sparse::matrix_handle_t handle; + float x[1], y[1]; + oneapi::mkl::sparse::gemv(q, oneapi::mkl::transpose::nontrans, 1, handle, x, 1, y); + return 0; + } + " MKL_TRY_SYCL_COMPILE) + break() + elseif(lib STREQUAL "mkl_sycl_data_fitting") + check_cxx_source_compiles(" + #include + #include \"oneapi/mkl/experimental/data_fitting.hpp\" + + int main() + { + namespace df = oneapi::mkl::experimental::data_fitting; + sycl::queue q; + df::spline spl(q); + return 0; + } + " MKL_TRY_SYCL_COMPILE) + break() + elseif(lib STREQUAL "mkl_sycl_rng") + check_cxx_source_compiles(" + #include + #include \"oneapi/mkl/rng.hpp\" + + int main() + { + sycl::queue q; + oneapi::mkl::rng::default_engine engine(q, 0); + return 0; + } + " MKL_TRY_SYCL_COMPILE) + break() + elseif(lib STREQUAL "mkl_sycl_stats") + check_cxx_source_compiles(" + #include + #include \"oneapi/mkl/stats.hpp\" + + int main() + { + namespace stats = oneapi::mkl::stats; + sycl::queue q; + float x[1], min[1]; + stats::min(q, stats::make_dataset(1, 1, x), min); + return 0; + } + " MKL_TRY_SYCL_COMPILE) + break() + elseif(lib STREQUAL "mkl_sycl_vm") + check_cxx_source_compiles(" + #include + #include \"oneapi/mkl/vm.hpp\" + + int main() + { + sycl::queue q; + float a[1], b[1], y[1]; + oneapi::mkl::vm::add(q, 1, a, b, y); + return 0; + } + " MKL_TRY_SYCL_COMPILE) + break() + endif() + endforeach() + unset(CMAKE_REQUIRED_LIBRARIES) + if(NOT MKL_TRY_SYCL_COMPILE) + mkl_not_found_and_return("The SYCL compiler \"${CMAKE_CXX_COMPILER}\" is not able to \ + compile a simple test program that calls a oneMKL DPC++ API. \ + See \"CMakeError.log\" for details. Besides environment issues, \ + this could be caused by a compiler version that is incompatible \ + with oneMKL ${${CMAKE_FIND_PACKAGE_NAME}_VERSION}.") + endif() +endif() + unset(MKL_DLL_FILE) +unset(MKL_LIBRARIES) -endif() # MKL_LIBRARIES +endif() # MKL::MKL diff --git a/cmake/mkl/MKLConfigVersion.cmake b/cmake/mkl/MKLConfigVersion.cmake index 996cd550f..e8ef98350 100755 --- a/cmake/mkl/MKLConfigVersion.cmake +++ b/cmake/mkl/MKLConfigVersion.cmake @@ -17,16 +17,16 @@ # SPDX-License-Identifier: Apache-2.0 #=============================================================================== -set(PACKAGE_VERSION "2023.2.0") +set(PACKAGE_VERSION "2024.2.0") if(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION) set(PACKAGE_VERSION_COMPATIBLE FALSE) else() - if("2023.2.0" MATCHES "^([0-9]+)\\.") + if("2024.2.0" MATCHES "^([0-9]+)\\.") set(CVF_VERSION_MAJOR "${CMAKE_MATCH_1}") else() - set(CVF_VERSION_MAJOR "2024.0.0") + set(CVF_VERSION_MAJOR "2024.2.0") endif() if(PACKAGE_FIND_VERSION_MAJOR STREQUAL CVF_VERSION_MAJOR)