[SYCL][UR][CUDA] Use FindCUDAToolkit CMake module instead of FindCUDA (#17315)

rafbiels · web-flow · commit 17df762be147 · 2025-03-12T10:17:26.000Z
`find_package(CUDA)` is deprecated since CMake 3.10 and the functionality we need is provided by `find_package(CUDAToolkit)` since CMake 3.17. Thanks to SYCL configuration now requiring CMake >3.20 (#13664), we can rely on `find_package(CUDAToolkit)` working in all setups. Changes: * Remove the deprecated calls and replace them with the recommended one. * Clean up all extra CMake code dealing with finding CUPTI as that is also now handled correctly by the FindCUDAToolkit module. * Replace all variables from the old module with corresponding ones from the new one, where they differ. * Update documentation on specifying custom CUDA installation path. This solves multiple issues with finding libraries, notably including the failure to find libcuda.so automatically on systems where the CUDA driver is not installed and only the toolkit is available. This is a reasonable use case for building DPC++ on a build machine without a GPU and distributing for use on GPU machines (easybuilders/easybuild-easyconfigs#22418 (comment)).
diff --git a/sycl/cmake/modules/FindCUDACupti.cmake b/sycl/cmake/modules/FindCUDACupti.cmake
diff --git a/sycl/doc/GetStartedGuide.md b/sycl/doc/GetStartedGuide.md
@@ -219,13 +219,12 @@ Firstly, **do not** add the toolkit to your standard environment variables
 (`PATH`, `LD_LIBRARY_PATH`), as to do so will create conflicts with OpenCL
 headers.
 
-Secondly, set the `CUDA_LIB_PATH` environment variable and pass the CMake
-variable `CUDA_TOOLKIT_ROOT_DIR` as follows:
+Secondly pass the CMake variable `CUDAToolkit_ROOT` as follows:
 
 ```sh
-CUDA_LIB_PATH=/path/to/cuda/toolkit/lib64/stubs CC=gcc CXX=g++ python $DPCPP_HOME/llvm/buildbot/configure.py --cuda --cmake-opt="-DCUDA_TOOLKIT_ROOT_DIR=/path/to/cuda/toolkit"
+CC=gcc CXX=g++ python $DPCPP_HOME/llvm/buildbot/configure.py --cuda --cmake-opt="-DCUDAToolkit_ROOT=/path/to/cuda/toolkit"
 
-CUDA_LIB_PATH=/path/to/cuda/toolkit/lib64/stubs CC=gcc CXX=g++ python $DPCPP_HOME/llvm/buildbot/compile.py
+CC=gcc CXX=g++ python $DPCPP_HOME/llvm/buildbot/compile.py
 
 $DPCPP_HOME/llvm/build/bin/clang++ -std=c++17 -O3 -fsycl -fsycl-targets=nvptx64-nvidia-cuda --cuda-path=/path/to/cuda/toolkit *.cpp -o a.out
 
diff --git a/sycl/tools/sycl-trace/CMakeLists.txt b/sycl/tools/sycl-trace/CMakeLists.txt
@@ -90,36 +90,25 @@ target_include_directories(sycl_ur_trace_collector PRIVATE
 
 if(SYCL_BUILD_BACKEND_CUDA)
 
-  find_package(CUDA 10.1 REQUIRED)
+  find_package(CUDAToolkit 10.1 REQUIRED)
 
   target_compile_definitions(cuda_trace_collector PRIVATE USE_UR_CUDA)
 
-  # The following two if's can be removed when FindCUDA -> FindCUDAToolkit.
-  # CUDA_CUPTI_INCLUDE_DIR -> CUDAToolkit_CUPTI_INCLUDE_DIR
-  include(FindCUDACupti)
-  if(NOT CUDA_CUPTI_INCLUDE_DIR)
-     find_cuda_cupti_include_dir()
-  endif()
-  # CUDA_cupti_LIBRARY -> CUDAToolkit_cupti_LIBRARY
-  if(NOT CUDA_cupti_LIBRARY)
-     find_cuda_cupti_library()
-  endif()
-
   target_include_directories(cuda_trace_collector
     PRIVATE
-    ${CUDA_CUPTI_INCLUDE_DIR}
+    ${CUDAToolkit_cupti_INCLUDE_DIR}
   )
 
   target_link_libraries(cuda_trace_collector
     PRIVATE
       cudadrv
-      ${CUDA_cupti_LIBRARY}
+      ${CUDAToolkit_cupti_LIBRARY}
   )
 
   find_path(GEN_CUDA_META_H_DIR generated_cuda_meta.h PATHS
-      "${CUDA_TOOLKIT_ROOT_DIR}/extras/CUPTI/include"
-      "${CUDA_INCLUDE_DIRS}/../extras/CUPTI/include"
-      "${CUDA_INCLUDE_DIRS}"
+      "${CUDAToolkit_ROOT}/extras/CUPTI/include"
+      "${CUDAToolkit_INCLUDE_DIRS}/../extras/CUPTI/include"
+      "${CUDAToolkit_INCLUDE_DIRS}"
       NO_DEFAULT_PATH)
 
   if( EXISTS "${GEN_CUDA_META_H_DIR}/generated_cuda_meta.h" )
diff --git a/unified-runtime/cmake/FindCUDACupti.cmake b/unified-runtime/cmake/FindCUDACupti.cmake
diff --git a/unified-runtime/source/adapters/cuda/CMakeLists.txt b/unified-runtime/source/adapters/cuda/CMakeLists.txt
@@ -54,22 +54,22 @@ set_target_properties(${TARGET_NAME} PROPERTIES
 )
 
 find_package(Threads REQUIRED)
-find_package(CUDA 10.1 REQUIRED)
+find_package(CUDAToolkit 10.1 REQUIRED)
 
 # Make imported library global to use it within the project.
 add_library(cudadrv SHARED IMPORTED GLOBAL)
 
 if (WIN32)
   set_target_properties(
     cudadrv PROPERTIES 
-      IMPORTED_IMPLIB               ${CUDA_CUDA_LIBRARY}
-      INTERFACE_INCLUDE_DIRECTORIES ${CUDA_INCLUDE_DIRS}
+      IMPORTED_IMPLIB               ${CUDA_cuda_driver_LIBRARY}
+      INTERFACE_INCLUDE_DIRECTORIES ${CUDAToolkit_INCLUDE_DIRS}
   )
 else()
   set_target_properties(
     cudadrv PROPERTIES 
-      IMPORTED_LOCATION             ${CUDA_CUDA_LIBRARY}
-      INTERFACE_INCLUDE_DIRECTORIES ${CUDA_INCLUDE_DIRS}
+      IMPORTED_LOCATION             ${CUDA_cuda_driver_LIBRARY}
+      INTERFACE_INCLUDE_DIRECTORIES ${CUDAToolkit_INCLUDE_DIRS}
   )
 endif()
 
@@ -82,17 +82,6 @@ endif()
 # Only enable xpti tracing on Linux as tracing tools aren't available on
 # Windows yet.
 if (UR_ENABLE_TRACING AND UNIX)
-  include(FindCUDACupti)
-  # The following two ifs can be removed when FindCUDA -> FindCUDAToolkit.
-  # CUDA_CUPTI_INCLUDE_DIR -> CUDAToolkit_CUPTI_INCLUDE_DIR
-  if(NOT CUDA_CUPTI_INCLUDE_DIR)
-    find_cuda_cupti_include_dir()
-  endif()
-  # CUDA_cupti_LIBRARY -> CUDAToolkit_cupti_LIBRARY
-  if(NOT CUDA_cupti_LIBRARY)
-    find_cuda_cupti_library()
-  endif()
-
   if (NOT XPTI_INCLUDES)
     get_target_property(XPTI_INCLUDES xpti INCLUDE_DIRECTORIES)
   endif()
@@ -106,7 +95,7 @@ if (UR_ENABLE_TRACING AND UNIX)
     )
   target_include_directories(${TARGET_NAME} PRIVATE
     ${XPTI_INCLUDES}
-    ${CUDA_CUPTI_INCLUDE_DIR}
+    ${CUDAToolkit_cupti_INCLUDE_DIR}
   )
   target_sources(${TARGET_NAME} PRIVATE ${XPTI_PROXY_SRC})
 endif()
diff --git a/unified-runtime/source/adapters/hip/CMakeLists.txt b/unified-runtime/source/adapters/hip/CMakeLists.txt
@@ -155,17 +155,17 @@ if("${UR_HIP_PLATFORM}" STREQUAL "AMD")
     target_compile_definitions(${TARGET_NAME} PRIVATE __HIP_PLATFORM_AMD__)
 elseif("${UR_HIP_PLATFORM}" STREQUAL "NVIDIA")
     # Import CUDA libraries
-    find_package(CUDA REQUIRED)
+    find_package(CUDAToolkit REQUIRED)
     find_package(Threads REQUIRED)
 
-    list(APPEND HIP_HEADERS ${CUDA_INCLUDE_DIRS})
+    list(APPEND HIP_HEADERS ${CUDAToolkit_INCLUDE_DIRS})
 
     # cudadrv may be defined by the CUDA plugin
     if(NOT TARGET cudadrv)
     add_library(cudadrv SHARED IMPORTED GLOBAL)
     set_target_properties(
         cudadrv PROPERTIES
-        IMPORTED_LOCATION                    ${CUDA_CUDA_LIBRARY}
+        IMPORTED_LOCATION                    ${CUDA_cuda_driver_LIBRARY}
         INTERFACE_INCLUDE_DIRECTORIES        "${HIP_HEADERS}"
         INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${HIP_HEADERS}"
     )
@@ -174,7 +174,7 @@ elseif("${UR_HIP_PLATFORM}" STREQUAL "NVIDIA")
     add_library(cudart SHARED IMPORTED GLOBAL)
     set_target_properties(
     cudart PROPERTIES
-        IMPORTED_LOCATION                    ${CUDA_CUDART_LIBRARY}
+        IMPORTED_LOCATION                    ${CUDA_cudart_LIBRARY}
         INTERFACE_INCLUDE_DIRECTORIES        "${HIP_HEADERS}"
         INTERFACE_SYSTEM_INCLUDE_DIRECTORIES "${HIP_HEADERS}"
     )
diff --git a/unified-runtime/source/common/CMakeLists.txt b/unified-runtime/source/common/CMakeLists.txt
@@ -12,9 +12,9 @@ else()
 endif()
 
 if (UR_BUILD_ADAPTER_CUDA)
-    find_package(CUDA 10.1 REQUIRED)
+    find_package(CUDAToolkit 10.1 REQUIRED)
     set(UMF_BUILD_CUDA_PROVIDER ON CACHE INTERNAL "Build UMF CUDA provider")
-    set(UMF_CUDA_INCLUDE_DIR "${CUDA_INCLUDE_DIRS}" CACHE INTERNAL "CUDA headers")
+    set(UMF_CUDA_INCLUDE_DIR "${CUDAToolkit_INCLUDE_DIRS}" CACHE INTERNAL "CUDA headers")
 else()
     set(UMF_BUILD_CUDA_PROVIDER OFF CACHE INTERNAL "Build UMF CUDA provider")
 endif()
