Add CUDA 13 support

.gitlab/jobs/matrix.yml

@@ -36,3 +36,8 @@ clang_18_1_8_cuda_12_6_0:
   variables:
     SPEC: " ~shared +cuda cuda_arch=90 +tests %llvm@=18.1.8 ^cuda@12.6.0+allow-unsupported-compilers"
   extends: .job_on_matrix
+
+clang_18_1_8_cuda_13_1_1:
+  variables:
+    SPEC: " ~shared +cuda cuda_arch=90 +tests %llvm@=18.1.8 ^cuda@13.1.1+allow-unsupported-compilers"
+  extends: .job_on_matrix

CMakeLists.txt

@@ -343,6 +343,12 @@ endif()
 
 if(RAJA_ENABLE_TESTS)
   add_subdirectory(test)
+else()
+  # For Spack stand-alone tests need host config information for building simple
+  # examples even if full tests are not done.
+  configure_file(
+    test/install/using-with-cmake/host-config.cmake.in
+    ${PROJECT_BINARY_DIR}/examples/using-with-cmake/host-config.cmake)
 endif()
 
 if(RAJA_ENABLE_REPRODUCERS)

cmake/thirdparty/FindCUB.cmake

@@ -14,7 +14,8 @@ find_path(CUB_INCLUDE_DIRS
   HINTS
     ${CUB_DIR}/
     ${CUB_DIR}/include
-    ${CUDA_TOOLKIT_ROOT_DIR}/include)
+    ${CUDA_TOOLKIT_ROOT_DIR}/include
+    ${CUDA_TOOLKIT_ROOT_DIR}/include/cccl)
 
 find_package_handle_standard_args(
   CUB

include/RAJA/pattern/thread.hpp

@@ -28,6 +28,7 @@
 
 namespace RAJA
 {
+
 /*!
  * \file
  * Thread operation functions in the namespace RAJA::thread
@@ -74,7 +75,7 @@ namespace RAJA
  * @return Maximum number of threads
  */
 template<typename Policy>
-RAJA_INLINE RAJA_HOST_DEVICE int get_max_threads()
+RAJA_INLINE int get_max_threads()
 {
   return RAJA::get_max_threads(Policy {});
 }
@@ -87,7 +88,7 @@ RAJA_INLINE RAJA_HOST_DEVICE int get_max_threads()
  * @return Current thread number
  */
 template<typename Policy>
-RAJA_INLINE RAJA_HOST_DEVICE int get_thread_num()
+RAJA_INLINE int get_thread_num()
 {
   return RAJA::get_thread_num(Policy {});
 }

include/RAJA/policy/cuda/MemUtils_CUDA.hpp

@@ -146,10 +146,26 @@ struct DevicePinnedAllocator
     void* ptr;
     CAMP_CUDA_API_INVOKE_AND_CHECK(cudaMallocManaged, &ptr, nbytes,
                                    cudaMemAttachGlobal);
+#if CUDART_VERSION >= 13000
+    cudaMemLocation devLoc {};
+    devLoc.type = cudaMemLocationTypeDevice;
+    devLoc.id   = device;
+
+    CAMP_CUDA_API_INVOKE_AND_CHECK(cudaMemAdvise, ptr, nbytes,
+                                   cudaMemAdviseSetPreferredLocation, devLoc);
+
+    cudaMemLocation cpuLoc {};
+    cpuLoc.type = cudaMemLocationTypeHost;
+    cpuLoc.id   = 0;
+
+    CAMP_CUDA_API_INVOKE_AND_CHECK(cudaMemAdvise, ptr, nbytes,
+                                   cudaMemAdviseSetAccessedBy, cpuLoc);
+#else
     CAMP_CUDA_API_INVOKE_AND_CHECK(cudaMemAdvise, ptr, nbytes,
                                    cudaMemAdviseSetPreferredLocation, device);
     CAMP_CUDA_API_INVOKE_AND_CHECK(cudaMemAdvise, ptr, nbytes,
                                    cudaMemAdviseSetAccessedBy, cudaCpuDeviceId);
+#endif
 
     return ptr;
   }

include/RAJA/policy/openmp/thread.hpp

@@ -32,18 +32,18 @@ namespace RAJA
 {
 
 template<>
-RAJA_HOST_DEVICE RAJA_INLINE int get_max_threads(omp_thread)
+RAJA_INLINE int get_max_threads(omp_thread)
 {
   return omp_get_max_threads();
 }
 
 template<>
-RAJA_HOST_DEVICE RAJA_INLINE int get_thread_num(omp_thread)
+RAJA_INLINE int get_thread_num(omp_thread)
 {
   return omp_get_thread_num();
 }
 
 }  // namespace RAJA
 
-#endif  // RAJA_ENABLE_OPENMP
-#endif  // guard
+#endif  // RAJA_OPENMP_ACTIVE
+#endif  // header file include guard

include/RAJA/policy/sequential/thread.hpp

@@ -29,13 +29,13 @@
 namespace RAJA
 {
 template<>
-RAJA_HOST_DEVICE RAJA_INLINE int get_max_threads(seq_thread)
+RAJA_INLINE int get_max_threads(seq_thread)
 {
   return 1;
 }
 
 template<>
-RAJA_HOST_DEVICE RAJA_INLINE int get_thread_num(seq_thread)
+RAJA_INLINE int get_thread_num(seq_thread)
 {
   return 0;
 }

include/RAJA/policy/thread_auto.hpp

@@ -52,11 +52,11 @@ using active_auto_thread = RAJA::seq_thread;
 }  // namespace detail
 
 template<typename AtomicPolicy>
-RAJA_HOST_DEVICE RAJA_INLINE int get_max_threads(AtomicPolicy);
+RAJA_INLINE int get_max_threads(AtomicPolicy);
 
 template<typename AtomicPolicy>
-RAJA_HOST_DEVICE RAJA_INLINE int get_thread_num(AtomicPolicy);
+RAJA_INLINE int get_thread_num(AtomicPolicy);
 
 }  // namespace RAJA
 
-#endif
+#endif  // header file include guard

include/RAJA/util/math.hpp

@@ -84,7 +84,10 @@ RAJA_HOST_DEVICE RAJA_INLINE constexpr T next_pow2(T n) noexcept
 template<typename T, std::enable_if_t<std::is_integral<T>::value>* = nullptr>
 RAJA_HOST_DEVICE RAJA_INLINE constexpr T prev_pow2(T n) noexcept
 {
-  if (n < 0) return 0;
+  if constexpr (std::is_signed_v<T>)
+  {
+    if (n < 0) return 0;
+  }
   for (size_t s = 1; s < CHAR_BIT * sizeof(T); s *= 2)
   {
     n |= n >> s;

scripts/lc-builds/toss4_cce_omptarget.sh

@@ -22,7 +22,7 @@ if [[ $# -lt 2 ]]; then
   echo "For example: "
   echo "    toss4_cce_omptarget.sh 20.0.0-magic gfx942 [3.27.4]"
   echo "If no CMake version is provided, version ${DEFAULT_CMAKE_VER} will be used."
-  exit 1"
+  exit 1
 fi
 
 COMP_VER=$1

test/unit/resource/tests/test-resource-AsyncTime.hpp

@@ -32,22 +32,31 @@ gpu_time_wait_for(float time, float clockrate) {
 int get_clockrate()
 {
   int cuda_device = 0;
-  cudaDeviceProp deviceProp;
   CAMP_CUDA_API_INVOKE_AND_CHECK(cudaGetDevice, &cuda_device);
-  CAMP_CUDA_API_INVOKE_AND_CHECK(cudaGetDeviceProperties, &deviceProp, cuda_device);
-  if ((deviceProp.concurrentKernels == 0))
+
+  int concurrentKernels = 0;
+  CAMP_CUDA_API_INVOKE_AND_CHECK(cudaDeviceGetAttribute,
+                                 &concurrentKernels,
+                                 cudaDevAttrConcurrentKernels,
+                                 cuda_device);
+
+  if (concurrentKernels == 0)
   {
     printf("> GPU does not support concurrent kernel execution\n");
     printf("  CUDA kernel runs will be serialized\n");
     return -1;
   }
-  //printf("> Detected Compute SM %d.%d hardware with %d multi-processors\n",
-  //    deviceProp.major, deviceProp.minor, deviceProp.multiProcessorCount);
+
+  int clockRate = 0;
+  CAMP_CUDA_API_INVOKE_AND_CHECK(cudaDeviceGetAttribute,
+                                 &clockRate,
+                                 cudaDevAttrClockRate,
+                                 cuda_device);
 
 #if defined(__arm__) || defined(__aarch64__)
-  return deviceProp.clockRate/1000;
+  return clockRate / 1000;
 #else
-  return deviceProp.clockRate;
+  return clockRate;
 #endif
 }
 

test/unit/util/test-fraction.cpp

@@ -32,7 +32,7 @@ void testFractionMultiplyTypesValues()
             IntegerType(double(numerator) / double(denominator) * double(101)));
 
   // Test where naive algorithm causes overflow, when within precision of double
-  if /*constexpr*/ (sizeof(IntegerType) < sizeof(double)) {
+  if constexpr (sizeof(IntegerType) < sizeof(double)) {
 
     static constexpr IntegerType max = std::numeric_limits<IntegerType>::max();
     static constexpr IntegerType val = (numerator > denominator) ?