add cmake function for autoselection of cuda arch

3 files changed, 258 insertions, 4 deletions

diff --git a/.SRCINFO b/.SRCINFO
index 75c7be6204e6..af69ff2f8a7d 100644
--- a/.SRCINFO
+++ b/.SRCINFO
@@ -1,7 +1,7 @@
 pkgbase = blender-2.8-git
 	pkgdesc = Development version of Blender 2.8 branch
 	pkgver = 2.8_r70965.673c9dce085
-	pkgrel = 1
+	pkgrel = 2
 	url = http://blender.org/
 	install = blender.install
 	arch = i686
@@ -38,12 +38,14 @@ pkgbase = blender-2.8-git
 	source = blender-translations.git::git://git.blender.org/blender-translations.git
 	source = blender-dev-tools.git::git://git.blender.org/blender-dev-tools.git
 	source = blender-2.8.desktop
+	source = SelectCudaComputeArch.cmake.patch
 	md5sums = SKIP
 	md5sums = SKIP
 	md5sums = SKIP
 	md5sums = SKIP
 	md5sums = SKIP
 	md5sums = cd108dca1c77607c6a7cc45aa284ea97
+	md5sums = d1ee53ea71d0617c28caba2774eaf3e0
 
 pkgname = blender-2.8-git
 
diff --git a/PKGBUILD b/PKGBUILD
index 1241fe0e5530..d51d6c9fe127 100644
--- a/PKGBUILD
+++ b/PKGBUILD
@@ -3,7 +3,7 @@
 
 pkgname=blender-2.8-git
 pkgver=2.8_r70965.673c9dce085
-pkgrel=1
+pkgrel=2
 pkgdesc="Development version of Blender 2.8 branch"
 arch=('i686' 'x86_64')
 url="http://blender.org/"
@@ -26,13 +26,15 @@ source=('git://git.blender.org/blender.git#branch=blender2.8' \
         'blender-addons-contrib.git::git://git.blender.org/blender-addons-contrib.git' \
         'blender-translations.git::git://git.blender.org/blender-translations.git' \
         'blender-dev-tools.git::git://git.blender.org/blender-dev-tools.git' \
-        blender-2.8.desktop)
+        blender-2.8.desktop \
+        SelectCudaComputeArch.cmake.patch)
 md5sums=('SKIP'
          'SKIP'
          'SKIP'
          'SKIP'
          'SKIP'
-         'cd108dca1c77607c6a7cc45aa284ea97')
+         'cd108dca1c77607c6a7cc45aa284ea97'
+         'd1ee53ea71d0617c28caba2774eaf3e0')
 
 # determine whether we can precompile CUDA kernels
 _CUDA_PKG=`pacman -Qq cuda 2>/dev/null` || true
@@ -52,6 +54,7 @@ prepare() {
   git submodule update --init --recursive
   git submodule foreach git checkout master
   git submodule foreach git pull --rebase origin master
+  patch -Np1 -i ../SelectCudaComputeArch.cmake.patch
 }
 
 build() {
diff --git a/SelectCudaComputeArch.cmake.patch b/SelectCudaComputeArch.cmake.patch
new file mode 100644
index 000000000000..9e0cead49008
--- /dev/null
+++ b/SelectCudaComputeArch.cmake.patch
@@ -0,0 +1,249 @@
+diff --git a/build_files/cmake/SelectCudaComputeArch.cmake b/build_files/cmake/SelectCudaComputeArch.cmake
+new file mode 100644
+index 00000000000..c3bf8639460
+--- /dev/null
++++ b/build_files/cmake/SelectCudaComputeArch.cmake
+@@ -0,0 +1,225 @@
++# CMake - Cross Platform Makefile Generator
++# Copyright 2000-2017 Kitware, Inc. and Contributors
++# All rights reserved.
++#
++# Redistribution and use in source and binary forms, with or without
++# modification, are permitted provided that the following conditions
++# are met:
++#
++# * Redistributions of source code must retain the above copyright
++#   notice, this list of conditions and the following disclaimer.
++#
++# * Redistributions in binary form must reproduce the above copyright
++#   notice, this list of conditions and the following disclaimer in the
++#   documentation and/or other materials provided with the distribution.
++#
++# * Neither the name of Kitware, Inc. nor the names of Contributors
++#   may be used to endorse or promote products derived from this
++#   software without specific prior written permission.
++#
++# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
++# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
++# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
++# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
++# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
++# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
++# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
++# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
++# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
++# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
++# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++
++# Synopsis:
++#   CUDA_SELECT_NVCC_ARCH_FLAGS(out_variable [target_CUDA_architectures])
++#   -- Selects GPU arch flags for nvcc based on target_CUDA_architectures
++#      target_CUDA_architectures : Auto | Common | All | LIST(ARCH_AND_PTX ...)
++#       - "Auto" detects local machine GPU compute arch at runtime.
++#       - "Common" and "All" cover common and entire subsets of architectures
++#      ARCH_AND_PTX : NAME | NUM.NUM | NUM.NUM(NUM.NUM) | NUM.NUM+PTX
++#      NAME: Fermi Kepler Maxwell Kepler+Tegra Kepler+Tesla Maxwell+Tegra Pascal
++#      NUM: Any number. Only those pairs are currently accepted by NVCC though:
++#            2.0 2.1 3.0 3.2 3.5 3.7 5.0 5.2 5.3 6.0 6.2
++#      Returns LIST of flags to be added to CUDA_NVCC_FLAGS in ${out_variable}
++#      Additionally, sets ${out_variable}_readable to the resulting numeric list
++#      Example:
++#       CUDA_SELECT_NVCC_ARCH_FLAGS(ARCH_FLAGS 3.0 3.5+PTX 5.2(5.0) Maxwell)
++#        LIST(APPEND CUDA_NVCC_FLAGS ${ARCH_FLAGS})
++#
++#      More info on CUDA architectures: https://en.wikipedia.org/wiki/CUDA
++#
++
++# This list will be used for CUDA_ARCH_NAME = All option
++set(CUDA_KNOWN_GPU_ARCHITECTURES  "Fermi" "Kepler" "Maxwell")
++
++# This list will be used for CUDA_ARCH_NAME = Common option (enabled by default)
++set(CUDA_COMMON_GPU_ARCHITECTURES "3.0" "3.5" "5.0")
++
++if (CUDA_VERSION VERSION_GREATER "6.5")
++  list(APPEND CUDA_KNOWN_GPU_ARCHITECTURES "Kepler+Tegra" "Kepler+Tesla" "Maxwell+Tegra")
++  list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "5.2")
++endif ()
++
++if (CUDA_VERSION VERSION_GREATER "7.5")
++  list(APPEND CUDA_KNOWN_GPU_ARCHITECTURES "Pascal")
++  list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "6.0" "6.1" "6.1+PTX")
++else()
++  list(APPEND CUDA_COMMON_GPU_ARCHITECTURES "5.2+PTX")
++endif ()
++
++
++
++################################################################################################
++# A function for automatic detection of GPUs installed  (if autodetection is enabled)
++# Usage:
++#   CUDA_DETECT_INSTALLED_GPUS(OUT_VARIABLE)
++#
++function(CUDA_DETECT_INSTALLED_GPUS OUT_VARIABLE)
++  if(NOT CUDA_GPU_DETECT_OUTPUT)
++    set(cufile ${PROJECT_BINARY_DIR}/detect_cuda_archs.cu)
++
++    file(WRITE ${cufile} ""
++      "#include <cstdio>\n"
++      "int main()\n"
++      "{\n"
++      "  int count = 0;\n"
++      "  if (cudaSuccess != cudaGetDeviceCount(&count)) return -1;\n"
++      "  if (count == 0) return -1;\n"
++      "  for (int device = 0; device < count; ++device)\n"
++      "  {\n"
++      "    cudaDeviceProp prop;\n"
++      "    if (cudaSuccess == cudaGetDeviceProperties(&prop, device))\n"
++      "      std::printf(\"%d.%d \", prop.major, prop.minor);\n"
++      "  }\n"
++      "  return 0;\n"
++      "}\n")
++
++    execute_process(COMMAND "${CUDA_NVCC_EXECUTABLE}" "--run" "${cufile}"
++                    WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/CMakeFiles/"
++                    RESULT_VARIABLE nvcc_res OUTPUT_VARIABLE nvcc_out
++                    ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
++
++    if(nvcc_res EQUAL 0)
++      string(REPLACE "2.1" "2.1(2.0)" nvcc_out "${nvcc_out}")
++      set(CUDA_GPU_DETECT_OUTPUT ${nvcc_out} CACHE INTERNAL "Returned GPU architetures from detect_gpus tool" FORCE)
++    endif()
++  endif()
++
++  if(NOT CUDA_GPU_DETECT_OUTPUT)
++    message(STATUS "Automatic GPU detection failed. Building for common architectures.")
++    set(${OUT_VARIABLE} ${CUDA_COMMON_GPU_ARCHITECTURES} PARENT_SCOPE)
++  else()
++    set(${OUT_VARIABLE} ${CUDA_GPU_DETECT_OUTPUT} PARENT_SCOPE)
++  endif()
++endfunction()
++
++
++################################################################################################
++# Function for selecting GPU arch flags for nvcc based on CUDA architectures from parameter list
++# Usage:
++#   SELECT_NVCC_ARCH_FLAGS(out_variable [list of CUDA compute archs])
++function(CUDA_SELECT_NVCC_ARCH_FLAGS out_variable)
++  set(CUDA_ARCH_LIST "${ARGN}")
++
++  if("X${CUDA_ARCH_LIST}" STREQUAL "X" )
++    set(CUDA_ARCH_LIST "Auto")
++  endif()
++
++  set(cuda_arch_bin)
++  set(cuda_arch_ptx)
++
++  if("${CUDA_ARCH_LIST}" STREQUAL "All")
++    set(CUDA_ARCH_LIST ${CUDA_KNOWN_GPU_ARCHITECTURES})
++  elseif("${CUDA_ARCH_LIST}" STREQUAL "Common")
++    set(CUDA_ARCH_LIST ${CUDA_COMMON_GPU_ARCHITECTURES})
++  elseif("${CUDA_ARCH_LIST}" STREQUAL "Auto")
++    CUDA_DETECT_INSTALLED_GPUS(CUDA_ARCH_LIST)
++  endif()
++
++  # Now process the list and look for names
++  string(REGEX REPLACE "[ \t]+" ";" CUDA_ARCH_LIST "${CUDA_ARCH_LIST}")
++  list(REMOVE_DUPLICATES CUDA_ARCH_LIST)
++  foreach(arch_name ${CUDA_ARCH_LIST})
++    set(arch_bin)
++    set(add_ptx FALSE)
++    # Check to see if we are compiling PTX
++    if(arch_name MATCHES "(.*)\\+PTX$")
++      set(add_ptx TRUE)
++      set(arch_name ${CMAKE_MATCH_1})
++    endif()
++    if(arch_name MATCHES "^([0-9]\\.[0-9](\\([0-9]\\.[0-9]\\))?)$")
++      set(arch_bin ${CMAKE_MATCH_1})
++      set(arch_ptx ${arch_bin})
++    else()
++      # Look for it in our list of known architectures
++      if(${arch_name} STREQUAL "Fermi")
++        set(arch_bin 2.0 "2.1(2.0)")
++      elseif(${arch_name} STREQUAL "Kepler+Tegra")
++        set(arch_bin 3.2)
++      elseif(${arch_name} STREQUAL "Kepler+Tesla")
++        set(arch_bin 3.7)
++      elseif(${arch_name} STREQUAL "Kepler")
++        set(arch_bin 3.0 3.5)
++        set(arch_ptx 3.5)
++      elseif(${arch_name} STREQUAL "Maxwell+Tegra")
++        set(arch_bin 5.3)
++      elseif(${arch_name} STREQUAL "Maxwell")
++        set(arch_bin 5.0 5.2)
++        set(arch_ptx 5.2)
++      elseif(${arch_name} STREQUAL "Pascal")
++        set(arch_bin 6.0 6.1)
++        set(arch_ptx 6.1)
++      else()
++        message(SEND_ERROR "Unknown CUDA Architecture Name ${arch_name} in CUDA_SELECT_NVCC_ARCH_FLAGS")
++      endif()
++    endif()
++    if(NOT arch_bin)
++      message(SEND_ERROR "arch_bin wasn't set for some reason")
++    endif()
++    list(APPEND cuda_arch_bin ${arch_bin})
++    if(add_ptx)
++      if (NOT arch_ptx)
++        set(arch_ptx ${arch_bin})
++      endif()
++      list(APPEND cuda_arch_ptx ${arch_ptx})
++    endif()
++  endforeach()
++
++  # remove dots and convert to lists
++  string(REGEX REPLACE "\\." "" cuda_arch_bin "${cuda_arch_bin}")
++  string(REGEX REPLACE "\\." "" cuda_arch_ptx "${cuda_arch_ptx}")
++  string(REGEX MATCHALL "[0-9()]+" cuda_arch_bin "${cuda_arch_bin}")
++  string(REGEX MATCHALL "[0-9]+"   cuda_arch_ptx "${cuda_arch_ptx}")
++
++  if(cuda_arch_bin)
++    list(REMOVE_DUPLICATES cuda_arch_bin)
++  endif()
++  if(cuda_arch_ptx)
++    list(REMOVE_DUPLICATES cuda_arch_ptx)
++  endif()
++
++  set(nvcc_flags "")
++  set(nvcc_archs_readable "")
++
++  # Tell NVCC to add binaries for the specified GPUs
++  foreach(arch ${cuda_arch_bin})
++    if(arch MATCHES "([0-9]+)\\(([0-9]+)\\)")
++      # User explicitly specified ARCH for the concrete CODE
++      list(APPEND nvcc_flags -gencode arch=compute_${CMAKE_MATCH_2},code=sm_${CMAKE_MATCH_1})
++      list(APPEND nvcc_archs_readable sm_${CMAKE_MATCH_1})
++    else()
++      # User didn't explicitly specify ARCH for the concrete CODE, we assume ARCH=CODE
++      list(APPEND nvcc_flags -gencode arch=compute_${arch},code=sm_${arch})
++      list(APPEND nvcc_archs_readable sm_${arch})
++    endif()
++  endforeach()
++
++  # Tell NVCC to add PTX intermediate code for the specified architectures
++  foreach(arch ${cuda_arch_ptx})
++    list(APPEND nvcc_flags -gencode arch=compute_${arch},code=compute_${arch})
++    list(APPEND nvcc_archs_readable compute_${arch})
++  endforeach()
++
++  string(REPLACE ";" " " nvcc_archs_readable "${nvcc_archs_readable}")
++  set(${out_variable}          ${nvcc_flags}          PARENT_SCOPE)
++  set(${out_variable}_readable ${nvcc_archs_readable} PARENT_SCOPE)
++endfunction()
+diff --git a/intern/cycles/cmake/external_libs.cmake b/intern/cycles/cmake/external_libs.cmake
+index df88b91f5ac..4b3335122b2 100644
+--- a/intern/cycles/cmake/external_libs.cmake
++++ b/intern/cycles/cmake/external_libs.cmake
+@@ -41,6 +41,13 @@ if(WITH_CYCLES_CUDA_BINARIES OR NOT WITH_CUDA_DYNLOAD)
+ 	find_package(CUDA) # Try to auto locate CUDA toolkit
+ 	if(CUDA_FOUND)
+ 		message(STATUS "CUDA nvcc = ${CUDA_NVCC_EXECUTABLE}")
++		
++		include(${CMAKE_SOURCE_DIR}/build_files/cmake/SelectCudaComputeArch.cmake)
++		CUDA_SELECT_NVCC_ARCH_FLAGS(CUDA_ARCH_FLAGS Auto)
++		set(CYCLES_CUDA_BINARIES_ARCH "${CUDA_ARCH_FLAGS_readable}")
++	        message(STATUS "Enabling CUDA support (version: ${CUDA_VERSION_STRING},"
++                       " archs: ${CUDA_ARCH_FLAGS_readable})")
++
+ 	else()
+ 		message(STATUS "CUDA compiler not found, disabling WITH_CYCLES_CUDA_BINARIES")
+ 		set(WITH_CYCLES_CUDA_BINARIES OFF)