cmake/gmxManageGPU.cmake

   1 #
   2 # This file is part of the GROMACS molecular simulation package.
   3 #
   4 # Copyright (c) 2012,2013,2014,2015,2016, 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 if(GMX_GPU AND GMX_DOUBLE)
  46     message(FATAL_ERROR "GPU acceleration is not available in double precision!")
  47 endif()
  48 if(GMX_GPU_AUTO AND GMX_DOUBLE)
  49     message(WARNING "GPU acceleration is not available in double precision, disabled!")
  50     set_property(CACHE GMX_GPU PROPERTY VALUE OFF)
  51     set_property(CACHE GMX_GPU_AUTO PROPERTY VALUE OFF)
  52 endif()
  53
  54 # detect GPUs in the build host machine
  55 if ((GMX_GPU OR GMX_GPU_AUTO) AND NOT GMX_GPU_DETECTION_DONE)
  56     include(gmxDetectGpu)
  57     gmx_detect_gpu()
  58 endif()
  59
  60 # CMake 3.0-3.1 has a bug in the following case, which breaks
  61 # configuration on at least BlueGene/Q. Fixed in 3.1.1
  62 if ((NOT CMAKE_VERSION VERSION_LESS "3.0.0") AND
  63     (CMAKE_VERSION VERSION_LESS "3.1.1") AND
  64         (CMAKE_CROSSCOMPILING AND NOT CMAKE_SYSTEM_PROCESSOR))
  65     message(STATUS "Cannot search for CUDA because the CMake find package has a bug. Set a valid CMAKE_SYSTEM_PROCESSOR if you need to detect CUDA")
  66 else()
  67     set(CAN_RUN_CUDA_FIND_PACKAGE 1)
  68 endif()
  69
  70 # We need to call find_package even when we've already done the detection/setup
  71 if(GMX_GPU OR GMX_GPU_AUTO AND CAN_RUN_CUDA_FIND_PACKAGE)
  72     if(NOT GMX_GPU AND NOT GMX_DETECT_GPU_AVAILABLE)
  73         # Stay quiet when detection has occured and found no GPU.
  74         # Noise is acceptable when there is a GPU or the user required one.
  75         set(FIND_CUDA_QUIETLY QUIET)
  76     endif()
  77     find_package(CUDA ${REQUIRED_CUDA_VERSION} ${FIND_CUDA_QUIETLY})
  78
  79     # Cmake 2.8.12 (and CMake 3.0) introduced a new bug where the cuda
  80     # library dir is added twice as an rpath on APPLE, which in turn causes
  81     # the install_name_tool to wreck the binaries when it tries to remove this
  82     # path. Since this is set inside the cuda module, we remove the extra rpath
  83     # added in the library string - an rpath is not a library anyway, and at
  84     # least for Gromacs this works on all CMake versions. This should be
  85     # reasonably future-proof, since newer versions of CMake appear to handle
  86     # the rpath automatically based on the provided library path, meaning
  87     # the explicit rpath specification is no longer needed.
  88     if(APPLE AND (CMAKE_VERSION VERSION_GREATER 2.8.11))
  89         foreach(elem ${CUDA_LIBRARIES})
  90             if(elem MATCHES "-Wl,.*")
  91                 list(REMOVE_ITEM CUDA_LIBRARIES ${elem})
  92             endif()
  93         endforeach(elem)
  94     endif()
  95 endif()
  96
  97 # Depending on the current vale of GMX_GPU and GMX_GPU_AUTO:
  98 # - OFF, FALSE: Will skip this detection/setup.
  99 # - OFF, TRUE : Will keep GMX_GPU=OFF if no CUDA is detected, but will assemble
 100 #               a warning message which will be issued at the end of the
 101 #               configuration if GPU(s) were found in the build system.
 102 # - ON , FALSE: The user requested GPU build and this requires CUDA, so we will
 103 #               fail if it is not available.
 104 # - ON , TRUE : Can't happen (GMX_GPU=ON can only be user-set at this point)
 105 if((GMX_GPU OR GMX_GPU_AUTO) AND NOT GMX_GPU_DETECTION_DONE)
 106     if (EXISTS ${CUDA_TOOLKIT_ROOT_DIR})
 107         set(CUDA_FOUND TRUE CACHE INTERNAL "Whether the CUDA toolkit was found" FORCE)
 108     else()
 109         set(CUDA_FOUND FALSE CACHE INTERNAL "Whether the CUDA toolkit was found" FORCE)
 110     endif()
 111
 112     # assemble warning/error message
 113     if (GMX_DETECT_GPU_AVAILABLE)
 114         set(_msg "${GMX_DETECT_GPU_COUNT} NVIDIA GPU(s) found in the system")
 115
 116         # append GPU names
 117         if (NOT GMX_DETECT_GPU_INFO STREQUAL "")
 118             set(_msg "${_msg}:")
 119             foreach(gpu ${GMX_DETECT_GPU_INFO})
 120                 set(_msg "${_msg}
 121 ${gpu}")
 122             endforeach()
 123         endif()
 124
 125         # TODO remove the second part of the message when we'll have compute
 126         # capability information from the detection.
 127         set(_msg "${_msg}
 128 Compute capability information not available, consult the NVIDIA website:
 129 https://developer.nvidia.com/cuda-gpus")
 130     endif()
 131
 132         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.
 133
 134 ${_msg}")
 135         unset(_msg)
 136
 137     if (NOT CUDA_FOUND)
 138         if (GMX_GPU_AUTO)
 139             # Disable GPU acceleration in auto mode
 140             message(STATUS "No compatible CUDA toolkit found (v5.0+), disabling native GPU acceleration")
 141             set_property(CACHE GMX_GPU PROPERTY VALUE OFF)
 142             set(CUDA_NOTFOUND_AUTO ON)
 143         else()
 144             # the user requested CUDA, but it wasn't found
 145             message(FATAL_ERROR "${CUDA_NOTFOUND_MESSAGE}")
 146         endif()
 147     else()
 148         if (GMX_GPU_AUTO)
 149             message(STATUS "Enabling native GPU acceleration")
 150             set_property(CACHE GMX_GPU PROPERTY VALUE ON)
 151         endif()
 152     endif() # NOT CUDA_FOUND
 153 endif()
 154
 155 # Try to find NVML if a GPU accelerated binary should be build.
 156 if (GMX_GPU)
 157     if (DEFINED NVML_LIBRARY)
 158         set(NVML_FIND_QUIETLY TRUE)
 159     endif()
 160     find_package(NVML)
 161     option(GMX_USE_NVML "Use NVML support for better CUDA performance" ${HAVE_NVML})
 162     mark_as_advanced(GMX_USE_NVML)
 163     if(GMX_USE_NVML)
 164         if(NVML_FOUND)
 165             include_directories(SYSTEM ${NVML_INCLUDE_DIR})
 166             set(HAVE_NVML 1)
 167             list(APPEND GMX_EXTRA_LIBRARIES ${NVML_LIBRARY})
 168         else()
 169             message(FATAL_ERROR "NVML support was required, but was not detected. Please consult the install guide.")
 170         endif()
 171     endif()
 172 endif()
 173
 174 # Annoyingly enough, FindCUDA leaves a few variables behind as non-advanced.
 175 # We need to mark these advanced outside the conditional, otherwise, if the
 176 # user turns GMX_GPU=OFF after a failed cmake pass, these variables will be
 177 # left behind in the cache.
 178 mark_as_advanced(CUDA_BUILD_CUBIN CUDA_BUILD_EMULATION CUDA_SDK_ROOT_DIR CUDA_VERBOSE_BUILD)
 179 if(NOT GMX_GPU)
 180     mark_as_advanced(CUDA_TOOLKIT_ROOT_DIR)
 181 endif()
 182
 183 # Try to execute ${CUDA_NVCC_EXECUTABLE} --version and set the output
 184 # (or an error string) in the argument variable.
 185 # Note that semicolon is used as separator for nvcc.
 186 #
 187 # Parameters:
 188 #   COMPILER_INFO   - [output variable] string with compiler path, ID and
 189 #                     some compiler-provided information
 190 #   COMPILER_FLAGS  - [output variable] flags for the compiler
 191 #
 192 macro(get_cuda_compiler_info COMPILER_INFO COMPILER_FLAGS)
 193     if(CUDA_NVCC_EXECUTABLE)
 194
 195         # Get the nvcc version string. This is multi-line, but since it is only 4 lines
 196         # and might change in the future it is better to store than trying to parse out
 197         # the version from the current format.
 198         execute_process(COMMAND ${CUDA_NVCC_EXECUTABLE} --version
 199             RESULT_VARIABLE _nvcc_version_res
 200             OUTPUT_VARIABLE _nvcc_version_out
 201             ERROR_VARIABLE  _nvcc_version_err
 202             OUTPUT_STRIP_TRAILING_WHITESPACE)
 203         if (${_nvcc_version_res} EQUAL 0)
 204             # Fix multi-line mess: Replace newline with ";" so we can use it in a define
 205             string(REPLACE "\n" ";" _nvcc_info_singleline ${_nvcc_version_out})
 206             SET(${COMPILER_INFO} "${CUDA_NVCC_EXECUTABLE} ${_nvcc_info_singleline}")
 207             string(TOUPPER ${CMAKE_BUILD_TYPE} _build_type)
 208             SET(_compiler_flags "${CUDA_NVCC_FLAGS_${_build_type}}")
 209             if(CUDA_PROPAGATE_HOST_FLAGS)
 210                 string(REGEX REPLACE "[ ]+" ";" _cxx_flags_nospace "${BUILD_CXXFLAGS}")
 211             endif()
 212             SET(${COMPILER_FLAGS} "${CUDA_NVCC_FLAGS}${CUDA_NVCC_FLAGS_${_build_type}}; ${_cxx_flags_nospace}")
 213         else()
 214             SET(${COMPILER_INFO} "N/A")
 215             SET(${COMPILER_FLAGS} "N/A")
 216         endif()
 217     endif()
 218 endmacro ()
 219
 220 include(CMakeDependentOption)
 221 include(gmxOptionUtilities)
 222 macro(gmx_gpu_setup)
 223     if(GMX_GPU)
 224         # set up nvcc options
 225         include(gmxManageNvccConfig)
 226
 227         gmx_check_if_changed(_cuda_version_changed CUDA_VERSION)
 228
 229         # Generate CUDA RT API version string which will end up in config.h
 230         # We do this because nvcc is silly enough to not define its own version
 231         # (which should match the CUDA runtime API version AFAICT) and we want to
 232         # avoid creating the fragile dependency on cuda_runtime_api.h.
 233         #
 234         # NOTE: CUDA v7.5 is expected to have nvcc define it own version, so in the
 235         # future we should switch to using that version string instead of our own.
 236         if (NOT GMX_CUDA_VERSION OR _cuda_version_changed)
 237             MATH(EXPR GMX_CUDA_VERSION "${CUDA_VERSION_MAJOR}*1000 + ${CUDA_VERSION_MINOR}*10")
 238         endif()
 239
 240         if (_cuda_version_changed)
 241             # check the generated CUDA API version against the one present in cuda_runtime_api.h
 242             try_compile(_get_cuda_version_compile_res
 243                 ${CMAKE_BINARY_DIR}
 244                 ${CMAKE_SOURCE_DIR}/cmake/TestCUDAVersion.c
 245                 COMPILE_DEFINITIONS "-DGMX_CUDA_VERSION=${GMX_CUDA_VERSION}"
 246                 CMAKE_FLAGS "-DINCLUDE_DIRECTORIES=${CUDA_TOOLKIT_INCLUDE}"
 247                 OUTPUT_VARIABLE _get_cuda_version_compile_out)
 248
 249             if (NOT _get_cuda_version_compile_res)
 250                 if (_get_cuda_version_compile_out MATCHES "CUDA version mismatch")
 251                     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.")
 252                 else()
 253                     message(FATAL_ERROR "Could not detect CUDA runtime API version")
 254                 endif()
 255             endif()
 256         endif()
 257
 258         # no OpenMP is no good!
 259         if(NOT GMX_OPENMP)
 260             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.")
 261         endif()
 262     endif() # GMX_GPU
 263
 264     cmake_dependent_option(GMX_CUDA_NB_SINGLE_COMPILATION_UNIT
 265         "Whether to compile the CUDA non-bonded module using a single compilation unit." ON
 266         "GMX_GPU" ON)
 267     mark_as_advanced(GMX_CUDA_NB_SINGLE_COMPILATION_UNIT)
 268
 269     if (GMX_GPU)
 270         # We need to use single compilation unit for kernels:
 271         # - when compiling for CC 2.x devices where buggy kernel code is generated
 272         gmx_check_if_changed(_gmx_cuda_target_changed GMX_CUDA_TARGET_SM GMX_CUDA_TARGET_COMPUTE CUDA_NVCC_FLAGS)
 273         if(_gmx_cuda_target_changed OR NOT GMX_GPU_DETECTION_DONE)
 274             if((NOT GMX_CUDA_TARGET_SM AND NOT GMX_CUDA_TARGET_COMPUTE) OR
 275                (GMX_CUDA_TARGET_SM MATCHES "2[01]" OR GMX_CUDA_TARGET_COMPUTE MATCHES "2[01]"))
 276                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.")
 277                 set_property(CACHE GMX_CUDA_NB_SINGLE_COMPILATION_UNIT PROPERTY VALUE ON)
 278             else()
 279                 message(STATUS "Enabling multiple compilation units for the CUDA non-bonded module.")
 280                 set_property(CACHE GMX_CUDA_NB_SINGLE_COMPILATION_UNIT PROPERTY VALUE OFF)
 281             endif()
 282         endif()
 283     endif()
 284 endmacro()