[backport] Compile with CTK13. (dmlc#11610) (dmlc#11670)

Author: trivialfis

src/common/cuda_dr_utils.cc

@@ -22,8 +22,14 @@ CuDriverApi::CuDriverApi() {
   // similar to dlopen, but without the need to release a handle.
   auto safe_load = [](xgboost::StringView name, auto **fnptr) {
     cudaDriverEntryPointQueryResult status;
+#if (CUDA_VERSION / 1000) >= 13
+    dh::safe_cuda(cudaGetDriverEntryPointByVersion(name.c_str(), reinterpret_cast<void **>(fnptr),
+                                                   12080, cudaEnablePerThreadDefaultStream,
+                                                   &status));
+#else
     dh::safe_cuda(cudaGetDriverEntryPoint(name.c_str(), reinterpret_cast<void **>(fnptr),
                                           cudaEnablePerThreadDefaultStream, &status));
+#endif  // (CUDA_VERSION / 1000) >= 13
     CHECK(status == cudaDriverEntryPointSuccess) << name;
     CHECK(*fnptr);
   };

src/common/resource.cu

@@ -1,5 +1,5 @@
 /**
- * Copyright 2024, XGBoost Contributors
+ * Copyright 2024-2025, XGBoost Contributors
  */
 #include "device_helpers.cuh"  // for CurrentDevice
 #include "resource.cuh"
@@ -18,14 +18,26 @@ CudaMmapResource::CudaMmapResource(StringView path, std::size_t offset, std::siz
               }},
       n_{length} {
   auto device = dh::CurrentDevice();
+#if (CUDA_VERSION / 1000) >= 13
+  cudaMemLocation loc;
+  loc.type = cudaMemLocationTypeDevice;
+  loc.id = device;
+#else
+  auto loc = device;
+#endif  // (CUDA_VERSION / 1000) >= 13
   dh::safe_cuda(
-      cudaMemAdvise(handle_->base_ptr, handle_->base_size, cudaMemAdviseSetReadMostly, device));
-  dh::safe_cuda(cudaMemAdvise(handle_->base_ptr, handle_->base_size,
-                              cudaMemAdviseSetPreferredLocation, device));
+      cudaMemAdvise(handle_->base_ptr, handle_->base_size, cudaMemAdviseSetReadMostly, loc));
   dh::safe_cuda(
-      cudaMemAdvise(handle_->base_ptr, handle_->base_size, cudaMemAdviseSetAccessedBy, device));
+      cudaMemAdvise(handle_->base_ptr, handle_->base_size, cudaMemAdviseSetPreferredLocation, loc));
+  dh::safe_cuda(
+      cudaMemAdvise(handle_->base_ptr, handle_->base_size, cudaMemAdviseSetAccessedBy, loc));
+#if (CUDA_VERSION / 1000) >= 13
+  dh::safe_cuda(
+      cudaMemPrefetchAsync(handle_->base_ptr, handle_->base_size, loc, 0, dh::DefaultStream()));
+#else
   dh::safe_cuda(
       cudaMemPrefetchAsync(handle_->base_ptr, handle_->base_size, device, dh::DefaultStream()));
+#endif  // (CUDA_VERSION / 1000) >= 13
 }
 
 [[nodiscard]] void* CudaMmapResource::Data() {

tests/cpp/common/test_cuda_host_allocator.cu

@@ -1,5 +1,5 @@
 /**
- * Copyright 2024, XGBoost Contributors
+ * Copyright 2024-2025, XGBoost Contributors
  */
 #include <gtest/gtest.h>
 #include <xgboost/context.h>  // for Context
@@ -28,8 +28,16 @@ TEST(CudaHostMalloc, Managed) {
   std::vector<float, common::cuda_impl::ManagedAllocator<float>> vec;
   vec.resize(10);
 #if defined(__linux__)
+#if (CUDA_VERSION / 1000) >= 13
+  cudaMemLocation loc;
+  loc.type = cudaMemLocationTypeDevice;
+  loc.id = 0;
+  dh::safe_cuda(
+      cudaMemPrefetchAsync(vec.data(), vec.size() * sizeof(float), loc, 0, dh::DefaultStream()));
+#else
   dh::safe_cuda(
       cudaMemPrefetchAsync(vec.data(), vec.size() * sizeof(float), 0, dh::DefaultStream()));
+#endif  // (CUDA_VERSION / 1000) >= 13
 #endif
   dh::DefaultStream().Sync();
 }