cmake/OpenCVDetectCUDA.cmake

   1 if(WIN32 AND NOT MSVC)
   2   message(STATUS "CUDA compilation is disabled (due to only Visual Studio compiler supported on your platform).")
   3   return()
   4 endif()
   5
   6 if(CMAKE_COMPILER_IS_GNUCXX AND NOT APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
   7   message(STATUS "CUDA compilation is disabled (due to Clang unsupported on your platform).")
   8   return()
   9 endif()
  10
  11 set(CMAKE_MODULE_PATH "${OpenCV_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
  12
  13 foreach(var INCLUDE LIBRARY PROGRAM)
  14   set(__old_frpm_${var} "${CMAKE_FIND_ROOT_PATH_MODE_${var}}")
  15 endforeach()
  16
  17 set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
  18 set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY BOTH)
  19 set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE NEVER)
  20
  21 find_package(CUDA "${MIN_VER_CUDA}" QUIET)
  22
  23 foreach(var INCLUDE LIBRARY PROGRAM)
  24   set(CMAKE_FIND_ROOT_PATH_MODE_${var} "${__old_frpm_${var}}")
  25 endforeach()
  26
  27 list(REMOVE_AT CMAKE_MODULE_PATH 0)
  28
  29 if(CUDA_FOUND)
  30   set(HAVE_CUDA 1)
  31
  32   if(WITH_CUFFT)
  33     set(HAVE_CUFFT 1)
  34   endif()
  35
  36   if(WITH_CUBLAS)
  37     set(HAVE_CUBLAS 1)
  38   endif()
  39
  40   if(WITH_NVCUVID)
  41     find_cuda_helper_libs(nvcuvid)
  42     if(WIN32)
  43       find_cuda_helper_libs(nvcuvenc)
  44     endif()
  45     set(HAVE_NVCUVID 1)
  46   endif()
  47
  48   message(STATUS "CUDA detected: " ${CUDA_VERSION})
  49
  50   set(_generations "Fermi" "Kepler")
  51   if(NOT CMAKE_CROSSCOMPILING)
  52     list(APPEND _generations "Auto")
  53   endif()
  54   set(CUDA_GENERATION "" CACHE STRING "Build CUDA device code only for specific GPU architecture. Leave empty to build for all architectures.")
  55   if( CMAKE_VERSION VERSION_GREATER "2.8" )
  56     set_property( CACHE CUDA_GENERATION PROPERTY STRINGS "" ${_generations} )
  57   endif()
  58
  59   if(CUDA_GENERATION)
  60     if(NOT ";${_generations};" MATCHES ";${CUDA_GENERATION};")
  61       string(REPLACE ";" ", " _generations "${_generations}")
  62       message(FATAL_ERROR "ERROR: ${_generations} Generations are suppered.")
  63     endif()
  64     unset(CUDA_ARCH_BIN CACHE)
  65     unset(CUDA_ARCH_PTX CACHE)
  66   endif()
  67
  68   set(__cuda_arch_ptx "")
  69   if(CUDA_GENERATION STREQUAL "Fermi")
  70     set(__cuda_arch_bin "2.0 2.1(2.0)")
  71   elseif(CUDA_GENERATION STREQUAL "Kepler")
  72     if(${CUDA_VERSION} VERSION_LESS "5.0")
  73       set(__cuda_arch_bin "3.0")
  74     else()
  75       set(__cuda_arch_bin "3.0 3.5")
  76     endif()
  77   elseif(CUDA_GENERATION STREQUAL "Auto")
  78     execute_process( COMMAND "${CUDA_NVCC_EXECUTABLE}" "${OpenCV_SOURCE_DIR}/cmake/checks/OpenCVDetectCudaArch.cu" "--run"
  79                      WORKING_DIRECTORY "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeTmp/"
  80                      RESULT_VARIABLE _nvcc_res OUTPUT_VARIABLE _nvcc_out
  81                      ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
  82     if(NOT _nvcc_res EQUAL 0)
  83       message(STATUS "Automatic detection of CUDA generation failed. Going to build for all known architectures.")
  84     else()
  85       set(__cuda_arch_bin "${_nvcc_out}")
  86       string(REPLACE "2.1" "2.1(2.0)" __cuda_arch_bin "${__cuda_arch_bin}")
  87     endif()
  88   endif()
  89
  90   if(NOT DEFINED __cuda_arch_bin)
  91     if(ANDROID)
  92       set(__cuda_arch_bin "3.2")
  93       set(__cuda_arch_ptx "")
  94     else()
  95       if(${CUDA_VERSION} VERSION_LESS "5.0")
  96         set(__cuda_arch_bin "1.1 1.2 1.3 2.0 2.1(2.0) 3.0")
  97       else()
  98         set(__cuda_arch_bin "1.1 1.2 1.3 2.0 2.1(2.0) 3.0 3.5")
  99       endif()
 100       set(__cuda_arch_ptx "3.0")
 101     endif()
 102   endif()
 103
 104   set(CUDA_ARCH_BIN ${__cuda_arch_bin} CACHE STRING "Specify 'real' GPU architectures to build binaries for, BIN(PTX) format is supported")
 105   set(CUDA_ARCH_PTX ${__cuda_arch_ptx} CACHE STRING "Specify 'virtual' PTX architectures to build PTX intermediate code for")
 106
 107   string(REGEX REPLACE "\\." "" ARCH_BIN_NO_POINTS "${CUDA_ARCH_BIN}")
 108   string(REGEX REPLACE "\\." "" ARCH_PTX_NO_POINTS "${CUDA_ARCH_PTX}")
 109
 110   # Ckeck if user specified 1.0 compute capability: we don't support it
 111   string(REGEX MATCH "1.0" HAS_ARCH_10 "${CUDA_ARCH_BIN} ${CUDA_ARCH_PTX}")
 112   set(CUDA_ARCH_BIN_OR_PTX_10 0)
 113   if(NOT ${HAS_ARCH_10} STREQUAL "")
 114     set(CUDA_ARCH_BIN_OR_PTX_10 1)
 115   endif()
 116
 117   # NVCC flags to be set
 118   set(NVCC_FLAGS_EXTRA "")
 119
 120   # These vars will be passed into the templates
 121   set(OPENCV_CUDA_ARCH_BIN "")
 122   set(OPENCV_CUDA_ARCH_PTX "")
 123   set(OPENCV_CUDA_ARCH_FEATURES "")
 124
 125   # Tell NVCC to add binaries for the specified GPUs
 126   string(REGEX MATCHALL "[0-9()]+" ARCH_LIST "${ARCH_BIN_NO_POINTS}")
 127   foreach(ARCH IN LISTS ARCH_LIST)
 128     if(ARCH MATCHES "([0-9]+)\\(([0-9]+)\\)")
 129       # User explicitly specified PTX for the concrete BIN
 130       set(NVCC_FLAGS_EXTRA ${NVCC_FLAGS_EXTRA} -gencode arch=compute_${CMAKE_MATCH_2},code=sm_${CMAKE_MATCH_1})
 131       set(OPENCV_CUDA_ARCH_BIN "${OPENCV_CUDA_ARCH_BIN} ${CMAKE_MATCH_1}")
 132       set(OPENCV_CUDA_ARCH_FEATURES "${OPENCV_CUDA_ARCH_FEATURES} ${CMAKE_MATCH_2}")
 133     else()
 134       # User didn't explicitly specify PTX for the concrete BIN, we assume PTX=BIN
 135       set(NVCC_FLAGS_EXTRA ${NVCC_FLAGS_EXTRA} -gencode arch=compute_${ARCH},code=sm_${ARCH})
 136       set(OPENCV_CUDA_ARCH_BIN "${OPENCV_CUDA_ARCH_BIN} ${ARCH}")
 137       set(OPENCV_CUDA_ARCH_FEATURES "${OPENCV_CUDA_ARCH_FEATURES} ${ARCH}")
 138     endif()
 139   endforeach()
 140
 141   # Tell NVCC to add PTX intermediate code for the specified architectures
 142   string(REGEX MATCHALL "[0-9]+" ARCH_LIST "${ARCH_PTX_NO_POINTS}")
 143   foreach(ARCH IN LISTS ARCH_LIST)
 144     set(NVCC_FLAGS_EXTRA ${NVCC_FLAGS_EXTRA} -gencode arch=compute_${ARCH},code=compute_${ARCH})
 145     set(OPENCV_CUDA_ARCH_PTX "${OPENCV_CUDA_ARCH_PTX} ${ARCH}")
 146     set(OPENCV_CUDA_ARCH_FEATURES "${OPENCV_CUDA_ARCH_FEATURES} ${ARCH}")
 147   endforeach()
 148
 149   # These vars will be processed in other scripts
 150   set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} ${NVCC_FLAGS_EXTRA})
 151   set(OpenCV_CUDA_CC "${NVCC_FLAGS_EXTRA}")
 152
 153   if(ANDROID)
 154     set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-Xptxas;-dlcm=ca")
 155     set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} "-target-os-variant=Android")
 156   endif()
 157
 158   message(STATUS "CUDA NVCC target flags: ${CUDA_NVCC_FLAGS}")
 159
 160   OCV_OPTION(CUDA_FAST_MATH "Enable --use_fast_math for CUDA compiler " OFF)
 161
 162   if(CUDA_FAST_MATH)
 163     set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} --use_fast_math)
 164   endif()
 165
 166   mark_as_advanced(CUDA_BUILD_CUBIN CUDA_BUILD_EMULATION CUDA_VERBOSE_BUILD CUDA_SDK_ROOT_DIR)
 167
 168   macro(ocv_cuda_compile VAR)
 169     foreach(var CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG)
 170       set(${var}_backup_in_cuda_compile_ "${${var}}")
 171
 172       # we remove /EHa as it generates warnings under windows
 173       string(REPLACE "/EHa" "" ${var} "${${var}}")
 174
 175       # we remove -ggdb3 flag as it leads to preprocessor errors when compiling CUDA files (CUDA 4.1)
 176       string(REPLACE "-ggdb3" "" ${var} "${${var}}")
 177
 178       # we remove -Wsign-promo as it generates warnings under linux
 179       string(REPLACE "-Wsign-promo" "" ${var} "${${var}}")
 180
 181       # we remove -Wno-sign-promo as it generates warnings under linux
 182       string(REPLACE "-Wno-sign-promo" "" ${var} "${${var}}")
 183
 184       # we remove -Wno-delete-non-virtual-dtor because it's used for C++ compiler
 185       # but NVCC uses C compiler by default
 186       string(REPLACE "-Wno-delete-non-virtual-dtor" "" ${var} "${${var}}")
 187
 188       # we remove -frtti because it's used for C++ compiler
 189       # but NVCC uses C compiler by default
 190       string(REPLACE "-frtti" "" ${var} "${${var}}")
 191     endforeach()
 192
 193     if(BUILD_SHARED_LIBS)
 194       set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -DCVAPI_EXPORTS)
 195     endif()
 196
 197     if(UNIX OR APPLE)
 198       set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fPIC)
 199     endif()
 200     if(APPLE)
 201       set(CUDA_NVCC_FLAGS ${CUDA_NVCC_FLAGS} -Xcompiler -fno-finite-math-only)
 202     endif()
 203
 204     # disabled because of multiple warnings during building nvcc auto generated files
 205     if(CMAKE_COMPILER_IS_GNUCXX AND CMAKE_GCC_REGEX_VERSION VERSION_GREATER "4.6.0")
 206       ocv_warnings_disable(CMAKE_CXX_FLAGS -Wunused-but-set-variable)
 207     endif()
 208
 209     CUDA_COMPILE(${VAR} ${ARGN})
 210
 211     foreach(var CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG)
 212       set(${var} "${${var}_backup_in_cuda_compile_}")
 213       unset(${var}_backup_in_cuda_compile_)
 214     endforeach()
 215   endmacro()
 216 else()
 217   unset(CUDA_ARCH_BIN CACHE)
 218   unset(CUDA_ARCH_PTX CACHE)
 219 endif()
 220
 221 if(HAVE_CUDA)
 222   set(CUDA_LIBS_PATH "")
 223   foreach(p ${CUDA_LIBRARIES} ${CUDA_npp_LIBRARY})
 224     get_filename_component(_tmp ${p} PATH)
 225     list(APPEND CUDA_LIBS_PATH ${_tmp})
 226   endforeach()
 227
 228   if(HAVE_CUBLAS)
 229     foreach(p ${CUDA_cublas_LIBRARY})
 230       get_filename_component(_tmp ${p} PATH)
 231       list(APPEND CUDA_LIBS_PATH ${_tmp})
 232     endforeach()
 233   endif()
 234
 235   if(HAVE_CUFFT)
 236     foreach(p ${CUDA_cufft_LIBRARY})
 237       get_filename_component(_tmp ${p} PATH)
 238       list(APPEND CUDA_LIBS_PATH ${_tmp})
 239     endforeach()
 240   endif()
 241
 242   list(REMOVE_DUPLICATES CUDA_LIBS_PATH)
 243   link_directories(${CUDA_LIBS_PATH})
 244
 245   set(CUDA_LIBRARIES_ABS ${CUDA_LIBRARIES})
 246   ocv_convert_to_lib_name(CUDA_LIBRARIES ${CUDA_LIBRARIES})
 247   set(CUDA_npp_LIBRARY_ABS ${CUDA_npp_LIBRARY})
 248   ocv_convert_to_lib_name(CUDA_npp_LIBRARY ${CUDA_npp_LIBRARY})
 249   if(HAVE_CUBLAS)
 250     set(CUDA_cublas_LIBRARY_ABS ${CUDA_cublas_LIBRARY})
 251     ocv_convert_to_lib_name(CUDA_cublas_LIBRARY ${CUDA_cublas_LIBRARY})
 252   endif()
 253
 254   if(HAVE_CUFFT)
 255     set(CUDA_cufft_LIBRARY_ABS ${CUDA_cufft_LIBRARY})
 256     ocv_convert_to_lib_name(CUDA_cufft_LIBRARY ${CUDA_cufft_LIBRARY})
 257   endif()
 258 endif()