cmake/gmxManageGPU.cmake

   1 #
   2 # This file is part of the GROMACS molecular simulation package.
   3 #
   4 # Copyright (c) 2012,2013,2014,2015,2016,2017, by the GROMACS development team, led by
   5 # Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   6 # and including many others, as listed in the AUTHORS file in the
   7 # top-level source directory and at http://www.gromacs.org.
   8 #
   9 # GROMACS is free software; you can redistribute it and/or
  10 # modify it under the terms of the GNU Lesser General Public License
  11 # as published by the Free Software Foundation; either version 2.1
  12 # of the License, or (at your option) any later version.
  13 #
  14 # GROMACS is distributed in the hope that it will be useful,
  15 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 # Lesser General Public License for more details.
  18 #
  19 # You should have received a copy of the GNU Lesser General Public
  20 # License along with GROMACS; if not, see
  21 # http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22 # Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23 #
  24 # If you want to redistribute modifications to GROMACS, please
  25 # consider that scientific software is very special. Version
  26 # control is crucial - bugs must be traceable. We will be happy to
  27 # consider code for inclusion in the official distribution, but
  28 # derived work must not be called official GROMACS. Details are found
  29 # in the README & COPYING files - if they are missing, get the
  30 # official version at http://www.gromacs.org.
  31 #
  32 # To help us fund GROMACS development, we humbly ask that you cite
  33 # the research papers on the package. Check out http://www.gromacs.org.
  34
  35 # If the user did not set GMX_GPU we'll consider this option to be
  36 # in "auto" mode meaning that we will:
  37 # - search for CUDA and set GMX_GPU=ON we find it
  38 # - check whether GPUs are present
  39 # - if CUDA is not found but GPUs were detected issue a warning
  40 if (NOT DEFINED GMX_GPU)
  41     set(GMX_GPU_AUTO TRUE CACHE INTERNAL "GPU acceleration will be selected automatically")
  42 endif()
  43 option(GMX_GPU "Enable GPU acceleration" OFF)
  44
  45 option(GMX_CLANG_CUDA "Use clang for CUDA" OFF)
  46 if (GMX_CLANG_CUDA)
  47     # CUDA 7.0 or later required, override req. version
  48     set(REQUIRED_CUDA_VERSION 7.0)
  49 endif()
  50
  51 if(GMX_GPU AND GMX_DOUBLE)
  52     message(FATAL_ERROR "GPU acceleration is not available in double precision!")
  53 endif()
  54 if(GMX_GPU_AUTO AND GMX_DOUBLE)
  55     message(WARNING "GPU acceleration is not available in double precision, disabled!")
  56     set_property(CACHE GMX_GPU PROPERTY VALUE OFF)
  57     set_property(CACHE GMX_GPU_AUTO PROPERTY VALUE OFF)
  58 endif()
  59
  60 # detect GPUs in the build host machine
  61 if ((GMX_GPU OR GMX_GPU_AUTO) AND NOT GMX_GPU_DETECTION_DONE)
  62     include(gmxDetectGpu)
  63     gmx_detect_gpu()
  64 endif()
  65
  66 # We need to call find_package even when we've already done the detection/setup
  67 if(GMX_GPU OR GMX_GPU_AUTO)
  68     if(NOT GMX_GPU AND NOT GMX_DETECT_GPU_AVAILABLE)
  69         # Stay quiet when detection has occured and found no GPU.
  70         # Noise is acceptable when there is a GPU or the user required one.
  71         set(FIND_CUDA_QUIETLY QUIET)
  72     endif()
  73
  74     # Cmake tries to use the static cuda runtime by default,
  75     # but this leads to unusable GPU builds on OS X.
  76     if(APPLE)
  77         set(CUDA_USE_STATIC_CUDA_RUNTIME OFF CACHE STRING "Use the static version of the CUDA runtime library if available")
  78     endif()
  79
  80     find_package(CUDA ${REQUIRED_CUDA_VERSION} ${FIND_CUDA_QUIETLY})
  81 endif()
  82
  83 # Depending on the current vale of GMX_GPU and GMX_GPU_AUTO:
  84 # - OFF, FALSE: Will skip this detection/setup.
  85 # - OFF, TRUE : Will keep GMX_GPU=OFF if no CUDA is detected, but will assemble
  86 #               a warning message which will be issued at the end of the
  87 #               configuration if GPU(s) were found in the build system.
  88 # - ON , FALSE: The user requested GPU build and this requires CUDA, so we will
  89 #               fail if it is not available.
  90 # - ON , TRUE : Can't happen (GMX_GPU=ON can only be user-set at this point)
  91 if((GMX_GPU OR GMX_GPU_AUTO) AND NOT GMX_GPU_DETECTION_DONE)
  92     if (EXISTS ${CUDA_TOOLKIT_ROOT_DIR})
  93         set(CUDA_FOUND TRUE CACHE INTERNAL "Whether the CUDA toolkit was found" FORCE)
  94     else()
  95         set(CUDA_FOUND FALSE CACHE INTERNAL "Whether the CUDA toolkit was found" FORCE)
  96     endif()
  97
  98     # assemble warning/error message
  99     if (GMX_DETECT_GPU_AVAILABLE)
 100         set(_msg "${GMX_DETECT_GPU_COUNT} NVIDIA GPU(s) found in the system")
 101
 102         # append GPU names
 103         if (NOT GMX_DETECT_GPU_INFO STREQUAL "")
 104             set(_msg "${_msg}:")
 105             foreach(gpu ${GMX_DETECT_GPU_INFO})
 106                 set(_msg "${_msg}
 107 ${gpu}")
 108             endforeach()
 109         endif()
 110
 111         # TODO remove the second part of the message when we'll have compute
 112         # capability information from the detection.
 113         set(_msg "${_msg}
 114 Compute capability information not available, consult the NVIDIA website:
 115 https://developer.nvidia.com/cuda-gpus")
 116     endif()
 117
 118         set(CUDA_NOTFOUND_MESSAGE "mdrun supports native GPU acceleration on NVIDIA hardware with compute capability >= ${REQUIRED_CUDA_COMPUTE_CAPABILITY} (Fermi or later). This requires the NVIDIA CUDA toolkit, which was not found. Its location can be hinted by setting the CUDA_TOOLKIT_ROOT_DIR CMake option (does not work as an environment variable). The typical location would be /usr/local/cuda[-version]. Note that CPU or GPU acceleration can be selected at runtime.
 119
 120 ${_msg}")
 121         unset(_msg)
 122
 123     if (NOT CUDA_FOUND)
 124         if (GMX_GPU_AUTO)
 125             # Disable GPU acceleration in auto mode
 126             message(STATUS "No compatible CUDA toolkit found (v5.0+), disabling native GPU acceleration")
 127             set_property(CACHE GMX_GPU PROPERTY VALUE OFF)
 128             set(CUDA_NOTFOUND_AUTO ON)
 129         else()
 130             # the user requested CUDA, but it wasn't found
 131             message(FATAL_ERROR "${CUDA_NOTFOUND_MESSAGE}")
 132         endif()
 133     else()
 134         if (GMX_GPU_AUTO)
 135             message(STATUS "Enabling native GPU acceleration")
 136             set_property(CACHE GMX_GPU PROPERTY VALUE ON)
 137         endif()
 138     endif() # NOT CUDA_FOUND
 139 endif()
 140
 141 # Try to find NVML if a GPU accelerated binary should be build.
 142 if (GMX_GPU)
 143     if (DEFINED NVML_LIBRARY)
 144         set(NVML_FIND_QUIETLY TRUE)
 145     endif()
 146     find_package(NVML)
 147     # TODO Default to off, since linking is not implemented reliably
 148     option(GMX_USE_NVML "Use NVML support for better CUDA performance" OFF)
 149     mark_as_advanced(GMX_USE_NVML)
 150     if(GMX_USE_NVML)
 151         if(NVML_FOUND)
 152             include_directories(SYSTEM ${NVML_INCLUDE_DIR})
 153             set(HAVE_NVML 1)
 154             list(APPEND GMX_EXTRA_LIBRARIES ${NVML_LIBRARY})
 155         else()
 156             message(FATAL_ERROR "NVML support was required, but was not detected. Please consult the install guide.")
 157         endif()
 158     endif()
 159 endif()
 160
 161 # Annoyingly enough, FindCUDA leaves a few variables behind as non-advanced.
 162 # We need to mark these advanced outside the conditional, otherwise, if the
 163 # user turns GMX_GPU=OFF after a failed cmake pass, these variables will be
 164 # left behind in the cache.
 165 mark_as_advanced(CUDA_SDK_ROOT_DIR
 166                  CUDA_USE_STATIC_CUDA_RUNTIME
 167                  CUDA_dl_LIBRARY CUDA_rt_LIBRARY
 168                  )
 169 if(NOT GMX_GPU)
 170     mark_as_advanced(CUDA_TOOLKIT_ROOT_DIR)
 171     mark_as_advanced(CUDA_HOST_COMPILER)
 172 endif()
 173
 174 # Try to execute ${CUDA_NVCC_EXECUTABLE} --version and set the output
 175 # (or an error string) in the argument variable.
 176 # Note that semicolon is used as separator for nvcc.
 177 #
 178 # Parameters:
 179 #   COMPILER_INFO   - [output variable] string with compiler path, ID and
 180 #                     some compiler-provided information
 181 #   COMPILER_FLAGS  - [output variable] flags for the compiler
 182 #
 183 macro(get_cuda_compiler_info COMPILER_INFO COMPILER_FLAGS)
 184     if(NOT GMX_CLANG_CUDA)
 185         if(CUDA_NVCC_EXECUTABLE)
 186
 187             # Get the nvcc version string. This is multi-line, but since it is only 4 lines
 188             # and might change in the future it is better to store than trying to parse out
 189             # the version from the current format.
 190             execute_process(COMMAND ${CUDA_NVCC_EXECUTABLE} --version
 191                 RESULT_VARIABLE _nvcc_version_res
 192                 OUTPUT_VARIABLE _nvcc_version_out
 193                 ERROR_VARIABLE  _nvcc_version_err
 194                 OUTPUT_STRIP_TRAILING_WHITESPACE)
 195             if (${_nvcc_version_res} EQUAL 0)
 196                 # Fix multi-line mess: Replace newline with ";" so we can use it in a define
 197                 string(REPLACE "\n" ";" _nvcc_info_singleline ${_nvcc_version_out})
 198                 SET(${COMPILER_INFO} "${CUDA_NVCC_EXECUTABLE} ${_nvcc_info_singleline}")
 199                 string(TOUPPER ${CMAKE_BUILD_TYPE} _build_type)
 200                 SET(_compiler_flags "${CUDA_NVCC_FLAGS_${_build_type}}")
 201                 if(CUDA_PROPAGATE_HOST_FLAGS)
 202                     string(REGEX REPLACE "[ ]+" ";" _cxx_flags_nospace "${BUILD_CXXFLAGS}")
 203                 endif()
 204                 SET(${COMPILER_FLAGS} "${CUDA_NVCC_FLAGS}${CUDA_NVCC_FLAGS_${_build_type}}; ${_cxx_flags_nospace}")
 205             else()
 206                 SET(${COMPILER_INFO} "N/A")
 207                 SET(${COMPILER_FLAGS} "N/A")
 208             endif()
 209         endif()
 210     else()
 211         # CXX compiler is the CUDA compiler
 212         set(${COMPILER_INFO} "${CMAKE_CXX_COMPILER}  ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}")
 213         # there are some extra flags
 214         set(${COMPILER_FLAGS} "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${_build_type}} ${GMX_CUDA_CLANG_FLAGS}")
 215     endif()
 216 endmacro ()
 217
 218 macro(enable_multiple_cuda_compilation_units)
 219     message(STATUS "Enabling multiple compilation units for the CUDA non-bonded module.")
 220     set_property(CACHE GMX_CUDA_NB_SINGLE_COMPILATION_UNIT PROPERTY VALUE OFF)
 221 endmacro()
 222
 223 include(CMakeDependentOption)
 224 include(gmxOptionUtilities)
 225 macro(gmx_gpu_setup)
 226     if(GMX_GPU)
 227         if(NOT GMX_CLANG_CUDA)
 228             if(NOT CUDA_NVCC_EXECUTABLE)
 229                 message(FATAL_ERROR "nvcc is required for a CUDA build, please set CUDA_TOOLKIT_ROOT_DIR appropriately")
 230             endif()
 231             # set up nvcc options
 232             include(gmxManageNvccConfig)
 233         else()
 234             include(gmxManageClangCudaConfig)
 235         endif()
 236
 237         gmx_check_if_changed(_cuda_version_changed CUDA_VERSION)
 238
 239         # Generate CUDA RT API version string which will end up in config.h
 240         # We do this because nvcc is silly enough to not define its own version
 241         # (which should match the CUDA runtime API version AFAICT) and we want to
 242         # avoid creating the fragile dependency on cuda_runtime_api.h.
 243         #
 244         # NOTE: CUDA v7.5 is expected to have nvcc define it own version, so in the
 245         # future we should switch to using that version string instead of our own.
 246         if (NOT GMX_CUDA_VERSION OR _cuda_version_changed)
 247             MATH(EXPR GMX_CUDA_VERSION "${CUDA_VERSION_MAJOR}*1000 + ${CUDA_VERSION_MINOR}*10")
 248         endif()
 249
 250         if (_cuda_version_changed)
 251             # check the generated CUDA API version against the one present in cuda_runtime_api.h
 252             try_compile(_get_cuda_version_compile_res
 253                 ${CMAKE_BINARY_DIR}
 254                 ${CMAKE_SOURCE_DIR}/cmake/TestCUDAVersion.c
 255                 COMPILE_DEFINITIONS "-DGMX_CUDA_VERSION=${GMX_CUDA_VERSION}"
 256                 CMAKE_FLAGS "-DINCLUDE_DIRECTORIES=${CUDA_TOOLKIT_INCLUDE}"
 257                 OUTPUT_VARIABLE _get_cuda_version_compile_out)
 258
 259             if (NOT _get_cuda_version_compile_res)
 260                 if (_get_cuda_version_compile_out MATCHES "CUDA version mismatch")
 261                     message(FATAL_ERROR "The CUDA API version generated internally from the compiler version does not match the version reported by cuda.h. This means either that the CUDA detection picked up mismatching nvcc and the CUDA headers (likely not part of the same toolkit installation) or that there is an error in the internal version generation. If you are sure that it is not the former causing the error (check the relevant cache variables), define the GMX_CUDA_VERSION cache variable to work around the error.")
 262                 else()
 263                     message(FATAL_ERROR "Could not detect CUDA runtime API version")
 264                 endif()
 265             endif()
 266         endif()
 267
 268         # no OpenMP is no good!
 269         if(NOT GMX_OPENMP)
 270             message(WARNING "To use GPU acceleration efficiently, mdrun requires OpenMP multi-threading. Without OpenMP a single CPU core can be used with a GPU which is not optimal. Note that with MPI multiple processes can be forced to use a single GPU, but this is typically inefficient. You need to set both C and C++ compilers that support OpenMP (CC and CXX environment variables, respectively) when using GPUs.")
 271         endif()
 272     endif() # GMX_GPU
 273
 274     if (GMX_CLANG_CUDA)
 275         set (_GMX_CUDA_NB_SINGLE_COMPILATION_UNIT_DEFAULT FALSE)
 276     else()
 277         set (_GMX_CUDA_NB_SINGLE_COMPILATION_UNIT_DEFAULT TRUE)
 278     endif()
 279     cmake_dependent_option(GMX_CUDA_NB_SINGLE_COMPILATION_UNIT
 280         "Whether to compile the CUDA non-bonded module using a single compilation unit." ${_GMX_CUDA_NB_SINGLE_COMPILATION_UNIT_DEFAULT}
 281         "GMX_GPU" ON)
 282     mark_as_advanced(GMX_CUDA_NB_SINGLE_COMPILATION_UNIT)
 283
 284     if (GMX_GPU AND NOT GMX_CLANG_CUDA)
 285         # We need to use single compilation unit for kernels:
 286         # when compiling with nvcc for CC 2.x devices where buggy kernel code is generated
 287         gmx_check_if_changed(_gmx_cuda_target_changed GMX_CUDA_TARGET_SM GMX_CUDA_TARGET_COMPUTE CUDA_NVCC_FLAGS)
 288
 289         if(_gmx_cuda_target_changed OR NOT GMX_GPU_DETECTION_DONE)
 290             if((NOT GMX_CUDA_TARGET_SM AND NOT GMX_CUDA_TARGET_COMPUTE) OR
 291                 (GMX_CUDA_TARGET_SM MATCHES "2[01]" OR GMX_CUDA_TARGET_COMPUTE MATCHES "2[01]"))
 292                 message(STATUS "Enabling single compilation unit for the CUDA non-bonded module. Multiple compilation units are not compatible with CC 2.x devices, to enable the feature specify only CC >=3.0 target architectures in GMX_CUDA_TARGET_SM/GMX_CUDA_TARGET_COMPUTE.")
 293                 set_property(CACHE GMX_CUDA_NB_SINGLE_COMPILATION_UNIT PROPERTY VALUE ON)
 294             else()
 295                 message(STATUS "Enabling multiple compilation units for the CUDA non-bonded module.")
 296                 set_property(CACHE GMX_CUDA_NB_SINGLE_COMPILATION_UNIT PROPERTY VALUE OFF)
 297             endif()
 298         endif()
 299     endif()
 300 endmacro()