Initial CUDA 13 work. Compiles and runs on RH9 with both CUDA 12 and 13.

Author: smithsg84

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;
   }

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
 }