Modules/FindCUDA/select_compute_arch.cmake

   1 # Synopsis:
   2 #   CUDA_SELECT_NVCC_ARCH_FLAGS(out_variable [target_CUDA_architectures])
   3 #   -- Selects GPU arch flags for nvcc based on target_CUDA_architectures
   4 #      target_CUDA_architectures : Auto | Common | All | LIST(ARCH_AND_PTX ...)
   5 #       - "Auto" detects local machine GPU compute arch at runtime.
   6 #       - "Common" and "All" cover common and entire subsets of architectures
   7 #      ARCH_AND_PTX : NAME | NUM.NUM | NUM.NUM(NUM.NUM) | NUM.NUM+PTX
   8 #      NAME: Fermi Kepler Maxwell Kepler+Tegra Kepler+Tesla Maxwell+Tegra Pascal
   9 #      NUM: Any number. Only those pairs are currently accepted by NVCC though:
  10 #            2.0 2.1 3.0 3.2 3.5 3.7 5.0 5.2 5.3 6.0 6.2
  11 #      Returns LIST of flags to be added to CUDA_NVCC_FLAGS in ${out_variable}
  12 #      Additionally, sets ${out_variable}_readable to the resulting numeric list
  13 #      Example:
  14 #       CUDA_SELECT_NVCC_ARCH_FLAGS(ARCH_FLAGS 3.0 3.5+PTX 5.2(5.0) Maxwell)
  15 #        LIST(APPEND CUDA_NVCC_FLAGS ${ARCH_FLAGS})
  16 #
  17 #      More info on CUDA architectures: https://en.wikipedia.org/wiki/CUDA
  18 #
  19
  20 if(CMAKE_CUDA_COMPILER_LOADED) # CUDA as a language
  21   if(CMAKE_CUDA_COMPILER_ID STREQUAL "NVIDIA"
  22       AND CMAKE_CUDA_COMPILER_VERSION MATCHES "^([0-9]+\\.[0-9]+)")
  23     set(CUDA_VERSION "${CMAKE_MATCH_1}")
  24   endif()
  25 endif()
  26
  27 # See: https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html#gpu-feature-list
  28
  29 # This list will be used for CUDA_ARCH_NAME = All option
  30 set(CUDA_KNOWN_GPU_ARCHITECTURES  "Fermi" "Kepler" "Maxwell")
  31
  32 # This list will be used for CUDA_ARCH_NAME = Common option (enabled by default)
  33 set(CUDA_COMMON_GPU_ARCHITECTURES "3.0" "3.5" "5.0")
  34
  35 if(CUDA_VERSION VERSION_LESS "7.0")
  36   set(CUDA_LIMIT_GPU_ARCHITECTURE "5.2")
  37 endif()
  38
  39 # This list is used to filter CUDA archs when autodetecting
  40 set(CUDA_ALL_GPU_ARCHITECTURES "3.0" "3.2" "3.5" "5.0")
  41
  42 if(CUDA_VERSION VERSION_GREATER_EQUAL "7.0")
  43   list(APPEND CUDA_KNOWN_GPU_ARCHITECTURES "Kepler+Tegra" "Kepler+Tesla" "Maxwell+Tegra")
  44   list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "5.2")
  45
  46   if(CUDA_VERSION VERSION_LESS "8.0")
  47     list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "5.2+PTX")
  48     set(CUDA_LIMIT_GPU_ARCHITECTURE "6.0")
  49   endif()
  50 endif()
  51
  52 if(CUDA_VERSION VERSION_GREATER_EQUAL "8.0")
  53   list(APPEND CUDA_KNOWN_GPU_ARCHITECTURES "Pascal")
  54   list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "6.0" "6.1")
  55   list(APPEND CUDA_ALL_GPU_ARCHITECTURES "6.0" "6.1" "6.2")
  56
  57   if(CUDA_VERSION VERSION_LESS "9.0")
  58     list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "6.1+PTX")
  59     set(CUDA_LIMIT_GPU_ARCHITECTURE "7.0")
  60   endif()
  61 endif ()
  62
  63 if(CUDA_VERSION VERSION_GREATER_EQUAL "9.0")
  64   list(APPEND CUDA_KNOWN_GPU_ARCHITECTURES "Volta")
  65   list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "7.0" "7.0+PTX")
  66
  67   if(CUDA_VERSION VERSION_LESS "10.0")
  68     set(CUDA_LIMIT_GPU_ARCHITECTURE "8.0")
  69   endif()
  70 endif()
  71
  72 ################################################################################################
  73 # A function for automatic detection of GPUs installed  (if autodetection is enabled)
  74 # Usage:
  75 #   CUDA_DETECT_INSTALLED_GPUS(OUT_VARIABLE)
  76 #
  77 function(CUDA_DETECT_INSTALLED_GPUS OUT_VARIABLE)
  78   if(NOT CUDA_GPU_DETECT_OUTPUT)
  79     if(CMAKE_CUDA_COMPILER_LOADED) # CUDA as a language
  80       set(file "${PROJECT_BINARY_DIR}/detect_cuda_compute_capabilities.cu")
  81     else()
  82       set(file "${PROJECT_BINARY_DIR}/detect_cuda_compute_capabilities.cpp")
  83     endif()
  84
  85     file(WRITE ${file} ""
  86       "#include <cuda_runtime.h>\n"
  87       "#include <cstdio>\n"
  88       "int main()\n"
  89       "{\n"
  90       "  int count = 0;\n"
  91       "  if (cudaSuccess != cudaGetDeviceCount(&count)) return -1;\n"
  92       "  if (count == 0) return -1;\n"
  93       "  for (int device = 0; device < count; ++device)\n"
  94       "  {\n"
  95       "    cudaDeviceProp prop;\n"
  96       "    if (cudaSuccess == cudaGetDeviceProperties(&prop, device))\n"
  97       "      std::printf(\"%d.%d \", prop.major, prop.minor);\n"
  98       "  }\n"
  99       "  return 0;\n"
 100       "}\n")
 101
 102     if(CMAKE_CUDA_COMPILER_LOADED) # CUDA as a language
 103       try_run(run_result compile_result ${PROJECT_BINARY_DIR} ${file}
 104               RUN_OUTPUT_VARIABLE compute_capabilities)
 105     else()
 106       try_run(run_result compile_result ${PROJECT_BINARY_DIR} ${file}
 107               CMAKE_FLAGS "-DINCLUDE_DIRECTORIES=${CUDA_INCLUDE_DIRS}"
 108               LINK_LIBRARIES ${CUDA_LIBRARIES}
 109               RUN_OUTPUT_VARIABLE compute_capabilities)
 110     endif()
 111
 112     if(run_result EQUAL 0)
 113       string(REPLACE "2.1" "2.1(2.0)" compute_capabilities "${compute_capabilities}")
 114       set(CUDA_GPU_DETECT_OUTPUT ${compute_capabilities}
 115         CACHE INTERNAL "Returned GPU architectures from detect_gpus tool" FORCE)
 116     endif()
 117   endif()
 118
 119   if(NOT CUDA_GPU_DETECT_OUTPUT)
 120     message(STATUS "Automatic GPU detection failed. Building for common architectures.")
 121     set(${OUT_VARIABLE} ${CUDA_COMMON_GPU_ARCHITECTURES} PARENT_SCOPE)
 122   else()
 123     # Filter based on CUDA version supported archs
 124     set(CUDA_GPU_DETECT_OUTPUT_FILTERED "")
 125     separate_arguments(CUDA_GPU_DETECT_OUTPUT)
 126     foreach(ITEM IN ITEMS ${CUDA_GPU_DETECT_OUTPUT})
 127         if(CUDA_LIMIT_GPU_ARCHITECTURE AND ITEM VERSION_GREATER_EQUAL CUDA_LIMIT_GPU_ARCHITECTURE)
 128         list(GET CUDA_COMMON_GPU_ARCHITECTURES -1 NEWITEM)
 129         string(APPEND CUDA_GPU_DETECT_OUTPUT_FILTERED " ${NEWITEM}")
 130       else()
 131         string(APPEND CUDA_GPU_DETECT_OUTPUT_FILTERED " ${ITEM}")
 132       endif()
 133     endforeach()
 134
 135     set(${OUT_VARIABLE} ${CUDA_GPU_DETECT_OUTPUT_FILTERED} PARENT_SCOPE)
 136   endif()
 137 endfunction()
 138
 139
 140 ################################################################################################
 141 # Function for selecting GPU arch flags for nvcc based on CUDA architectures from parameter list
 142 # Usage:
 143 #   SELECT_NVCC_ARCH_FLAGS(out_variable [list of CUDA compute archs])
 144 function(CUDA_SELECT_NVCC_ARCH_FLAGS out_variable)
 145   set(CUDA_ARCH_LIST "${ARGN}")
 146
 147   if("X${CUDA_ARCH_LIST}" STREQUAL "X" )
 148     set(CUDA_ARCH_LIST "Auto")
 149   endif()
 150
 151   set(cuda_arch_bin)
 152   set(cuda_arch_ptx)
 153
 154   if("${CUDA_ARCH_LIST}" STREQUAL "All")
 155     set(CUDA_ARCH_LIST ${CUDA_KNOWN_GPU_ARCHITECTURES})
 156   elseif("${CUDA_ARCH_LIST}" STREQUAL "Common")
 157     set(CUDA_ARCH_LIST ${CUDA_COMMON_GPU_ARCHITECTURES})
 158   elseif("${CUDA_ARCH_LIST}" STREQUAL "Auto")
 159     CUDA_DETECT_INSTALLED_GPUS(CUDA_ARCH_LIST)
 160     message(STATUS "Autodetected CUDA architecture(s): ${CUDA_ARCH_LIST}")
 161   endif()
 162
 163   # Now process the list and look for names
 164   string(REGEX REPLACE "[ \t]+" ";" CUDA_ARCH_LIST "${CUDA_ARCH_LIST}")
 165   list(REMOVE_DUPLICATES CUDA_ARCH_LIST)
 166   foreach(arch_name ${CUDA_ARCH_LIST})
 167     set(arch_bin)
 168     set(arch_ptx)
 169     set(add_ptx FALSE)
 170     # Check to see if we are compiling PTX
 171     if(arch_name MATCHES "(.*)\\+PTX$")
 172       set(add_ptx TRUE)
 173       set(arch_name ${CMAKE_MATCH_1})
 174     endif()
 175     if(arch_name MATCHES "^([0-9]\\.[0-9](\\([0-9]\\.[0-9]\\))?)$")
 176       set(arch_bin ${CMAKE_MATCH_1})
 177       set(arch_ptx ${arch_bin})
 178     else()
 179       # Look for it in our list of known architectures
 180       if(${arch_name} STREQUAL "Fermi")
 181         set(arch_bin 2.0 "2.1(2.0)")
 182       elseif(${arch_name} STREQUAL "Kepler+Tegra")
 183         set(arch_bin 3.2)
 184       elseif(${arch_name} STREQUAL "Kepler+Tesla")
 185         set(arch_bin 3.7)
 186       elseif(${arch_name} STREQUAL "Kepler")
 187         set(arch_bin 3.0 3.5)
 188         set(arch_ptx 3.5)
 189       elseif(${arch_name} STREQUAL "Maxwell+Tegra")
 190         set(arch_bin 5.3)
 191       elseif(${arch_name} STREQUAL "Maxwell")
 192         set(arch_bin 5.0 5.2)
 193         set(arch_ptx 5.2)
 194       elseif(${arch_name} STREQUAL "Pascal")
 195         set(arch_bin 6.0 6.1)
 196         set(arch_ptx 6.1)
 197       elseif(${arch_name} STREQUAL "Volta")
 198         set(arch_bin 7.0 7.0)
 199         set(arch_ptx 7.0)
 200       else()
 201         message(SEND_ERROR "Unknown CUDA Architecture Name ${arch_name} in CUDA_SELECT_NVCC_ARCH_FLAGS")
 202       endif()
 203     endif()
 204     if(NOT arch_bin)
 205       message(SEND_ERROR "arch_bin wasn't set for some reason")
 206     endif()
 207     list(APPEND cuda_arch_bin ${arch_bin})
 208     if(add_ptx)
 209       if (NOT arch_ptx)
 210         set(arch_ptx ${arch_bin})
 211       endif()
 212       list(APPEND cuda_arch_ptx ${arch_ptx})
 213     endif()
 214   endforeach()
 215
 216   # remove dots and convert to lists
 217   string(REGEX REPLACE "\\." "" cuda_arch_bin "${cuda_arch_bin}")
 218   string(REGEX REPLACE "\\." "" cuda_arch_ptx "${cuda_arch_ptx}")
 219   string(REGEX MATCHALL "[0-9()]+" cuda_arch_bin "${cuda_arch_bin}")
 220   string(REGEX MATCHALL "[0-9]+"   cuda_arch_ptx "${cuda_arch_ptx}")
 221
 222   if(cuda_arch_bin)
 223     list(REMOVE_DUPLICATES cuda_arch_bin)
 224   endif()
 225   if(cuda_arch_ptx)
 226     list(REMOVE_DUPLICATES cuda_arch_ptx)
 227   endif()
 228
 229   set(nvcc_flags "")
 230   set(nvcc_archs_readable "")
 231
 232   # Tell NVCC to add binaries for the specified GPUs
 233   foreach(arch ${cuda_arch_bin})
 234     if(arch MATCHES "([0-9]+)\\(([0-9]+)\\)")
 235       # User explicitly specified ARCH for the concrete CODE
 236       list(APPEND nvcc_flags -gencode arch=compute_${CMAKE_MATCH_2},code=sm_${CMAKE_MATCH_1})
 237       list(APPEND nvcc_archs_readable sm_${CMAKE_MATCH_1})
 238     else()
 239       # User didn't explicitly specify ARCH for the concrete CODE, we assume ARCH=CODE
 240       list(APPEND nvcc_flags -gencode arch=compute_${arch},code=sm_${arch})
 241       list(APPEND nvcc_archs_readable sm_${arch})
 242     endif()
 243   endforeach()
 244
 245   # Tell NVCC to add PTX intermediate code for the specified architectures
 246   foreach(arch ${cuda_arch_ptx})
 247     list(APPEND nvcc_flags -gencode arch=compute_${arch},code=compute_${arch})
 248     list(APPEND nvcc_archs_readable compute_${arch})
 249   endforeach()
 250
 251   string(REPLACE ";" " " nvcc_archs_readable "${nvcc_archs_readable}")
 252   set(${out_variable}          ${nvcc_flags}          PARENT_SCOPE)
 253   set(${out_variable}_readable ${nvcc_archs_readable} PARENT_SCOPE)
 254 endfunction()