* CMake: Add support for detecting the compute archs of the GPUs in your system

  at configure time.
* gpuCI: Add a GPU node configuration that builds and tests as little as possible.
* gpuCI: Cleanup logic for different build and test configurations.
* gpuCI: Fix an unfortunate typo in `determine_build_parallelism.bash` which
  led to the parallelism level not being set.

Author: brycelelbach

ci/common/build.bash

@@ -37,8 +37,8 @@ cd build
 # The Docker image sets up `${CXX}` and `${CUDACXX}`.
 CMAKE_FLAGS="-G Ninja -DCMAKE_CXX_COMPILER='${CXX}' -DCMAKE_CUDA_COMPILER='${CUDACXX}'"
 
-if [ "${BUILD_MODE}" == "branch" ]; then
-  # Post-commit build.
+if [ "${BUILD_TYPE}" == "cpu" ] && [ "${BUILD_MODE}" == "branch" ]; then
+  # Post-commit CPU CI builds (greatest coverage).
   CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_INCLUDE_CUB_CMAKE=ON"
   CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_ENABLE_MULTICONFIG=ON"
   CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_MULTICONFIG_ENABLE_DIALECT_CPP11=ON"
@@ -50,13 +50,8 @@ if [ "${BUILD_MODE}" == "branch" ]; then
   CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_MULTICONFIG_ENABLE_SYSTEM_OMP=ON"
   CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_MULTICONFIG_ENABLE_SYSTEM_CUDA=ON"
   CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_MULTICONFIG_WORKLOAD=LARGE"
-else
-  # Pre-commit build.
-  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_DISABLE_ARCH_BY_DEFAULT=ON"
-  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_ENABLE_COMPUTE_50=ON"
-  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_ENABLE_COMPUTE_60=ON"
-  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_ENABLE_COMPUTE_70=ON"
-  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_ENABLE_COMPUTE_80=ON"
+elif [ "${BUILD_TYPE}" == "cpu" ] || [ "${BUILD_TYPE}" == "local" ]; then
+  # Pre-commit CPU CI builds and local builds.
   CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_INCLUDE_CUB_CMAKE=ON"
   CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_ENABLE_MULTICONFIG=ON"
   CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_MULTICONFIG_ENABLE_DIALECT_CPP11=ON"
@@ -68,6 +63,19 @@ else
   CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_MULTICONFIG_ENABLE_SYSTEM_OMP=ON"
   CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_MULTICONFIG_ENABLE_SYSTEM_CUDA=ON"
   CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_MULTICONFIG_WORKLOAD=SMALL"
+  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_AUTO_DETECT_COMPUTE_ARCHS=ON"
+  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_ENABLE_COMPUTE_50=ON"
+  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_ENABLE_COMPUTE_60=ON"
+  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_ENABLE_COMPUTE_70=ON"
+  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_ENABLE_COMPUTE_80=ON"
+elif [ "${BUILD_TYPE}" == "gpu" ]; then
+  # Pre- and post-commit GPU CI builds (least coverage).
+  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_INCLUDE_CUB_CMAKE=ON"
+  CMAKE_FLAGS="${CMAKE_FLAGS} -DCUB_TEST_WORKLOAD=BASIC"
+  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_HOST_SYSTEM=CPP"
+  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_DEVICE_SYSTEM=CUDA"
+  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_CPP_DIALECT=14"
+  CMAKE_FLAGS="${CMAKE_FLAGS} -DTHRUST_AUTO_DETECT_COMPUTE_ARCHS=ON"
 fi
 
 CMAKE_BUILD_FLAGS="-j${PARALLEL_LEVEL}"
@@ -79,7 +87,11 @@ fi
 CTEST_FLAGS=""
 
 if [ "${BUILD_TYPE}" == "cpu" ]; then
+  # Pre- and post-commit CPU CI tests.
   CTEST_FLAGS="${CTEST_FLAGS} -E ^cub|^thrust.*cuda"
+elif [ "${BUILD_TYPE}" == "gpu" ]; then
+  # Pre- and post-commit GPU CI tests (least coverage).
+  CTEST_FLAGS="${CTEST_FLAGS} -E ^cub.*thorough|quicker$"
 fi
 
 if [ ! -z "${@}" ]; then
@@ -102,15 +114,18 @@ ${CUDACXX} --version
 ################################################################################
 
 logger "Configure Thrust and CUB..."
+echo cmake .. ${CMAKE_FLAGS}
 cmake .. ${CMAKE_FLAGS}
 
 logger "Build Thrust and CUB..."
+echo cmake --build . ${CMAKE_BUILD_FLAGS}
 cmake --build . ${CMAKE_BUILD_FLAGS}
 
 ################################################################################
 # TEST - Run Thrust and CUB examples and tests.
 ################################################################################
 
 logger "Test Thrust and CUB..."
+echo ctest ${CTEST_FLAGS}
 ctest ${CTEST_FLAGS}
 

ci/common/determine_build_parallelism.bash

@@ -58,9 +58,9 @@ export MEM_BOUND_THREADS=$((${TOTAL_MEM_KB} / (2 * 1000 * 1000))) # 2 GB / Build
 
 # Pick the smaller of the two as the default.
 if [ ${MEM_BOUND_THREADS} -lt ${CPU_BOUND_THREADS} ]; then
-  export PARLLEL_LEVEL=${MEM_BOUND_THREADS}
+  export PARALLEL_LEVEL=${MEM_BOUND_THREADS}
 else
-  export PARLLEL_LEVEL=${CPU_BOUND_THREADS}
+  export PARALLEL_LEVEL=${CPU_BOUND_THREADS}
 fi
 
 if [ "${QUIET}" == 0 ]; then
@@ -69,6 +69,6 @@ if [ "${QUIET}" == 0 ]; then
   echo "Total Mem:         ${TOTAL_MEM_KB} [kb]"
   echo "CPU Bound Threads: ${CPU_BOUND_THREADS} [threads]"
   echo "Mem Bound Threads: ${MEM_BOUND_THREADS} [threads]"
-  echo "Parallel Level:    ${PARLLEL_LEVEL} [threads]"
+  echo "Parallel Level:    ${PARALLEL_LEVEL} [threads]"
 fi
 

ci/local/build.bash

@@ -193,8 +193,9 @@ docker run --rm -it ${GPU_OPTS} \
   -v "${PASSWD_PATH}":/etc/passwd:ro \
   -v "${GROUP_PATH}":/etc/group:ro \
   -e "WORKSPACE=${REPOSITORY_PATH_IN_CONTAINER}" \
-  -e "BUILD_TYPE=gpu" \
+  -e "BUILD_TYPE=local" \
   -e "PARALLEL_LEVEL=${PARALLEL_LEVEL}" \
   -w "${BUILD_PATH_IN_CONTAINER}" \
   "${IMAGE}" bash -c "${COMMAND}"
 
+

cmake/ThrustCudaConfig.cmake

@@ -36,6 +36,30 @@ list(LENGTH THRUST_KNOWN_COMPUTE_ARCHS max_idx)
 math(EXPR max_idx "${max_idx} - 1")
 list(GET THRUST_KNOWN_COMPUTE_ARCHS ${max_idx} highest_arch)
 
+option(THRUST_AUTO_DETECT_COMPUTE_ARCHS
+  "If ON, CUDA architectures for all GPUs in the current system are enabled and all other CUDA architectures are disabled."
+  OFF
+)
+
+if (THRUST_AUTO_DETECT_COMPUTE_ARCHS)
+  set(detect_compute_archs_source ${Thrust_SOURCE_DIR}/cmake/detect_compute_archs.cu)
+  set(detect_compute_archs_exe ${PROJECT_BINARY_DIR}/detect_compute_archs)
+  set(detect_compute_archs_error_log ${PROJECT_BINARY_DIR}/detect_compute_archs.stderr.log)
+  execute_process(
+    COMMAND ${CMAKE_CUDA_COMPILER}
+      -std=c++11
+      -o ${detect_compute_archs_exe}
+      --run
+      ${detect_compute_archs_source}
+    OUTPUT_VARIABLE detected_archs
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    ERROR_FILE ${detect_compute_archs_error_log})
+  foreach (arch IN LISTS detected_archs)
+    string(APPEND detected_message " sm_${arch}")
+  endforeach()
+  message(STATUS "Thrust: Automatically detected CUDA architectures:${detected_message}")
+endif()
+
 set(option_init OFF)
 if ("Feta" STREQUAL "${CMAKE_CUDA_COMPILER_ID}")
   set(option_init ON)
@@ -46,15 +70,21 @@ option(THRUST_DISABLE_ARCH_BY_DEFAULT
 )
 
 set(option_init ON)
-if (THRUST_DISABLE_ARCH_BY_DEFAULT)
+if (THRUST_DISABLE_ARCH_BY_DEFAULT OR THRUST_AUTO_DETECT_COMPUTE_ARCHS)
   set(option_init OFF)
 endif()
 
 set(num_archs_enabled 0)
 foreach (arch IN LISTS THRUST_KNOWN_COMPUTE_ARCHS)
+  set(this_option_init ${option_init})
+
+  if (${arch} IN_LIST detected_archs)
+    set(this_option_init ON)
+  endif()
+
   option(THRUST_ENABLE_COMPUTE_${arch}
     "Enable code generation for tests for sm_${arch}"
-    ${option_init}
+    ${this_option_init}
   )
 
   if (NOT THRUST_ENABLE_COMPUTE_${arch})
@@ -75,7 +105,7 @@ foreach (arch IN LISTS THRUST_KNOWN_COMPUTE_ARCHS)
     set(arch_flag "-gencode arch=compute_${arch},code=sm_${arch}")
   endif()
 
-  string(APPEND COMPUTE_MESSAGE " sm_${arch}")
+  string(APPEND compute_message " sm_${arch}")
   string(APPEND THRUST_CUDA_FLAGS_NO_RDC " ${arch_flag}")
   if (NOT arch IN_LIST no_rdc_archs)
     string(APPEND THRUST_CUDA_FLAGS_RDC " ${arch_flag}")
@@ -91,11 +121,11 @@ if (NOT "Feta" STREQUAL "${CMAKE_CUDA_COMPILER_ID}")
     string(APPEND THRUST_CUDA_FLAGS_BASE
       " -gencode arch=compute_${highest_arch},code=compute_${highest_arch}"
     )
-    string(APPEND COMPUTE_MESSAGE " compute_${highest_arch}")
+    string(APPEND compute_message " compute_${highest_arch}")
   endif()
 endif()
 
-message(STATUS "Thrust: Enabled CUDA architectures:${COMPUTE_MESSAGE}")
+message(STATUS "Thrust: Enabled CUDA architectures:${compute_message}")
 
 # RDC is off by default in NVCC and on by default in Feta. Turning off RDC
 # isn't currently supported by Feta. So, we default to RDC off for NVCC and

cmake/detect_compute_archs.cu

@@ -0,0 +1,43 @@
+/*
+ *  Copyright 2019-2020 NVIDIA Corporation
+ *
+ *  Licensed under the Apache License, Version 2.0 (the "License");
+ *  you may not use this file except in compliance with the License.
+ *  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
+ */
+
+#include <cstdio>
+#include <set>
+#include <string>
+
+int main(int argc, char** argv) {
+  std::set<std::string> archs;
+  int devices;
+  if ((cudaGetDeviceCount(&devices) == cudaSuccess) && (devices > 0)) {
+    for (int dev = 0; dev < devices; ++dev) {
+      char buff[32];
+      cudaDeviceProp prop;
+      if(cudaGetDeviceProperties(&prop, dev) != cudaSuccess) continue;
+      sprintf(buff, "%d%d", prop.major, prop.minor);
+      archs.insert(buff);
+    }
+  }
+  if (archs.empty()) {
+    printf("ALL");
+  } else {
+    bool first = true;
+    for(const auto& arch : archs) {
+      printf(first ? "%s" : ";%s", arch.c_str());
+      first = false;
+    }
+  }
+  printf("\n");
+}