Globalize the include of <cuda_runtime_api.h> (NVIDIA#4704)

davebayer · miscco · web-flow · commit dde8e1151e64 · 2025-05-19T15:46:47.000+02:00
Co-authored-by: Michael Schellenberger Costa &lt;miscco@nvidia.com&gt;
diff --git a/libcudacxx/include/cuda/__annotated_ptr/access_property.h b/libcudacxx/include/cuda/__annotated_ptr/access_property.h
@@ -25,8 +25,6 @@
 #include <cuda/std/cstddef>
 #include <cuda/std/cstdint>
 
-#include <cuda_runtime_api.h>
-
 #include <cuda/std/__cccl/prologue.h>
 
 _LIBCUDACXX_BEGIN_NAMESPACE_CUDA
@@ -53,24 +51,30 @@ class access_property
   {};
   struct persisting
   {
+#if _CCCL_HAS_CTK()
     [[nodiscard]] _LIBCUDACXX_HIDE_FROM_ABI constexpr operator cudaAccessProperty() const noexcept
     {
       return cudaAccessProperty::cudaAccessPropertyPersisting;
     }
+#endif // _CCCL_HAS_CTK()
   };
   struct streaming
   {
+#if _CCCL_HAS_CTK()
     [[nodiscard]] _LIBCUDACXX_HIDE_FROM_ABI constexpr operator cudaAccessProperty() const noexcept
     {
       return cudaAccessProperty::cudaAccessPropertyStreaming;
     }
+#endif // _CCCL_HAS_CTK()
   };
   struct normal
   {
+#if _CCCL_HAS_CTK()
     [[nodiscard]] _LIBCUDACXX_HIDE_FROM_ABI constexpr operator cudaAccessProperty() const noexcept
     {
       return cudaAccessProperty::cudaAccessPropertyNormal;
     }
+#endif // _CCCL_HAS_CTK()
   };
 
   _CCCL_HIDE_FROM_ABI access_property() noexcept = default;
diff --git a/libcudacxx/include/cuda/__functional/get_device_address.h b/libcudacxx/include/cuda/__functional/get_device_address.h
@@ -23,10 +23,6 @@
 
 #if _CCCL_HAS_CTK()
 
-#  if !_CCCL_HAS_CUDA_COMPILER() || _CCCL_CUDA_COMPILER(CLANG)
-#    include <cuda_runtime_api.h>
-#  endif // !_CCCL_HAS_CUDA_COMPILER() || _CCCL_CUDA_COMPILER(CLANG)
-
 #  include <cuda/std/__cuda/api_wrapper.h>
 #  include <cuda/std/__memory/addressof.h>
 
diff --git a/libcudacxx/include/cuda/__mdspan/host_device_accessor.h b/libcudacxx/include/cuda/__mdspan/host_device_accessor.h
@@ -21,10 +21,6 @@
 #  pragma system_header
 #endif // no system header
 
-#if !_CCCL_HAS_CUDA_COMPILER || _CCCL_CUDA_COMPILER(CLANG)
-#  include <cuda_runtime_api.h>
-#endif // _CCCL_CUDA_COMPILER(CLANG)
-
 #include <cuda/std/__concepts/concept_macros.h>
 #include <cuda/std/__cuda/api_wrapper.h>
 #include <cuda/std/__iterator/concepts.h>
@@ -107,6 +103,7 @@ class __host_accessor : public _Accessor
   [[nodiscard]] _LIBCUDACXX_HIDE_FROM_ABI static constexpr bool
   __is_host_accessible_pointer([[maybe_unused]] __data_handle_type __p) noexcept
   {
+#if _CCCL_HAS_CTK()
     if constexpr (_CUDA_VSTD::contiguous_iterator<__data_handle_type>)
     {
       ::cudaPointerAttributes __ptr_attrib{};
@@ -115,6 +112,7 @@ class __host_accessor : public _Accessor
       return __ptr_attrib.hostPointer != nullptr || __ptr_attrib.type == ::cudaMemoryTypeUnregistered;
     }
     else
+#endif // _CCCL_HAS_CTK()
     {
       return true; // cannot be verified
     }
@@ -222,6 +220,7 @@ class __device_accessor : public _Accessor
   [[nodiscard]] _LIBCUDACXX_HIDE_FROM_ABI static constexpr bool
   __is_device_accessible_pointer([[maybe_unused]] __data_handle_type __p) noexcept
   {
+#if _CCCL_HAS_CTK()
     if constexpr (_CUDA_VSTD::contiguous_iterator<__data_handle_type>)
     {
       ::cudaPointerAttributes __ptr_attrib{};
@@ -230,6 +229,7 @@ class __device_accessor : public _Accessor
       return __ptr_attrib.devicePointer != nullptr || __ptr_attrib.type == ::cudaMemoryTypeUnregistered;
     }
     else
+#endif // _CCCL_HAS_CTK()
     {
       return true; // cannot be verified
     }
@@ -342,6 +342,7 @@ class __managed_accessor : public _Accessor
   [[nodiscard]] _LIBCUDACXX_HIDE_FROM_ABI static constexpr bool
   __is_managed_pointer([[maybe_unused]] __data_handle_type __p) noexcept
   {
+#if _CCCL_HAS_CTK()
     if constexpr (_CUDA_VSTD::contiguous_iterator<__data_handle_type>)
     {
       ::cudaPointerAttributes __ptr_attrib{};
@@ -350,6 +351,7 @@ class __managed_accessor : public _Accessor
       return __ptr_attrib.devicePointer != nullptr && __ptr_attrib.hostPointer == __ptr_attrib.devicePointer;
     }
     else
+#endif // _CCCL_HAS_CTK()
     {
       return true; // cannot be verified
     }
diff --git a/libcudacxx/include/cuda/std/__cccl/cuda_capabilities.h b/libcudacxx/include/cuda/std/__cccl/cuda_capabilities.h
@@ -21,10 +21,7 @@
 #  pragma system_header
 #endif // no system header
 
-// CUDA headers might not be present when using NVRTC, see NVIDIA/cccl#2095 for detail
-#if !_CCCL_COMPILER(NVRTC)
-#  include <cuda_runtime_api.h>
-#endif // !_CCCL_COMPILER(NVRTC)
+#include <cuda/std/__cccl/cuda_toolkit.h>
 
 #include <nv/target>
 
diff --git a/libcudacxx/include/cuda/std/__cuda/api_wrapper.h b/libcudacxx/include/cuda/std/__cuda/api_wrapper.h
@@ -21,10 +21,6 @@
 #  pragma system_header
 #endif // no system header
 
-#if _CCCL_CUDA_COMPILER(CLANG)
-#  include <cuda_runtime_api.h>
-#endif // _CCCL_CUDA_COMPILER(CLANG)
-
 #include <cuda/std/__exception/cuda_error.h>
 
 #define _CCCL_TRY_CUDA_API(_NAME, _MSG, ...)                \
diff --git a/libcudacxx/include/cuda/std/__cuda/ensure_current_device.h b/libcudacxx/include/cuda/std/__cuda/ensure_current_device.h
@@ -21,17 +21,15 @@
 #  pragma system_header
 #endif // no system header
 
-#if _CCCL_CUDA_COMPILER(CLANG)
-#  include <cuda_runtime_api.h>
-#endif // _CCCL_CUDA_COMPILER(CLANG)
+#if _CCCL_HAS_CTK()
 
-#include <cuda/std/__cuda/api_wrapper.h>
+#  include <cuda/std/__cuda/api_wrapper.h>
 
-#include <cuda/std/__cccl/prologue.h>
+#  include <cuda/std/__cccl/prologue.h>
 
 _LIBCUDACXX_BEGIN_NAMESPACE_CUDA
 
-#if !_CCCL_COMPILER(NVRTC)
+#  if !_CCCL_COMPILER(NVRTC)
 
 //! @brief `__ensure_current_device` is a simple helper that the current device is set to the right one.
 //! Only changes the current device if the target device is not the current one
@@ -63,10 +61,12 @@ struct __ensure_current_device
   }
 };
 
-#endif // !_CCCL_COMPILER(NVRTC)
+#  endif // !_CCCL_COMPILER(NVRTC)
 
 _LIBCUDACXX_END_NAMESPACE_CUDA
 
-#include <cuda/std/__cccl/epilogue.h>
+#  include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CCCL_HAS_CTK()
 
 #endif //_CUDA__STD__CUDA_ENSURE_CURRENT_DEVICE_H
diff --git a/libcudacxx/include/cuda/std/__exception/cuda_error.h b/libcudacxx/include/cuda/std/__exception/cuda_error.h
@@ -22,12 +22,6 @@
 #  pragma system_header
 #endif // no system header
 
-#if !_CCCL_COMPILER(NVRTC)
-#  if _CCCL_HAS_CUDA_COMPILER()
-#    include <cuda_runtime_api.h>
-#  endif // _CCCL_HAS_CUDA_COMPILER()
-#endif // !_CCCL_COMPILER(NVRTC)
-
 #include <cuda/std/__exception/terminate.h>
 #include <cuda/std/source_location>
 
@@ -67,11 +61,11 @@ static char* __format_cuda_error(
     __loc.line(),
     __api ? __api : "",
     __api ? " " : "",
-#  if _CCCL_HAS_CUDA_COMPILER()
+#  if _CCCL_HAS_CTK()
     ::cudaGetErrorString(::cudaError_t(__status)),
-#  else
+#  else // ^^^ _CCCL_HAS_CTK() ^^^ / vvv !_CCCL_HAS_CTK() vvv
     "cudaError",
-#  endif
+#  endif // ^^^ !_CCCL_HAS_CTK() ^^^
     __status,
     __msg);
   return __msg_buffer.__buffer;
diff --git a/libcudacxx/include/cuda/std/__tuple_dir/vector_types.h b/libcudacxx/include/cuda/std/__tuple_dir/vector_types.h
@@ -34,10 +34,6 @@ _CCCL_DIAG_SUPPRESS_CLANG("-Wmismatched-tags")
 #  include <cuda/std/__utility/forward.h>
 #  include <cuda/std/__utility/move.h>
 
-#  if !_CCCL_CUDA_COMPILATION()
-#    include <cuda_runtime_api.h>
-#  endif // !_CCCL_CUDA_COMPILATION()
-
 #  define _LIBCUDACXX_SPECIALIZE_TUPLE_INTERFACE(__name, __type, __size)              \
     template <>                                                                       \
     struct tuple_size<__name##__size> : _CUDA_VSTD::integral_constant<size_t, __size> \
diff --git a/libcudacxx/include/cuda/stream_ref b/libcudacxx/include/cuda/stream_ref
@@ -48,13 +48,13 @@ private:
 #  pragma system_header
 #endif // no system header
 
-#include <cuda/std/__cuda/api_wrapper.h>
-#include <cuda/std/__exception/cuda_error.h>
-#include <cuda/std/cstddef>
+#if _CCCL_HAS_CTK()
 
-#include <cuda_runtime_api.h>
+#  include <cuda/std/__cuda/api_wrapper.h>
+#  include <cuda/std/__exception/cuda_error.h>
+#  include <cuda/std/cstddef>
 
-#include <cuda/std/__cccl/prologue.h>
+#  include <cuda/std/__cccl/prologue.h>
 
 _LIBCUDACXX_BEGIN_NAMESPACE_CUDA
 
@@ -200,6 +200,8 @@ public:
 
 _LIBCUDACXX_END_NAMESPACE_CUDA
 
-#include <cuda/std/__cccl/epilogue.h>
+#  include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CCCL_HAS_CTK()
 
 #endif //_CUDA_STREAM_REF

Original file line number	Diff line number	Diff line change
`@@ -25,8 +25,6 @@`
`25`	`25`	`#include <cuda/std/cstddef>`
`26`	`26`	`#include <cuda/std/cstdint>`
`27`	`27`
`28`		`-#include <cuda_runtime_api.h>`
`29`		`-`
`30`	`28`	`#include <cuda/std/__cccl/prologue.h>`
`31`	`29`
`32`	`30`	`_LIBCUDACXX_BEGIN_NAMESPACE_CUDA`
`@@ -53,24 +51,30 @@ class access_property`
`53`	`51`	`{};`
`54`	`52`	`struct persisting`
`55`	`53`	`{`
	`54`	`+#if _CCCL_HAS_CTK()`
`56`	`55`	`[[nodiscard]] _LIBCUDACXX_HIDE_FROM_ABI constexpr operator cudaAccessProperty() const noexcept`
`57`	`56`	`{`
`58`	`57`	`return cudaAccessProperty::cudaAccessPropertyPersisting;`
`59`	`58`	`}`
	`59`	`+#endif // _CCCL_HAS_CTK()`
`60`	`60`	`};`
`61`	`61`	`struct streaming`
`62`	`62`	`{`
	`63`	`+#if _CCCL_HAS_CTK()`
`63`	`64`	`[[nodiscard]] _LIBCUDACXX_HIDE_FROM_ABI constexpr operator cudaAccessProperty() const noexcept`
`64`	`65`	`{`
`65`	`66`	`return cudaAccessProperty::cudaAccessPropertyStreaming;`
`66`	`67`	`}`
	`68`	`+#endif // _CCCL_HAS_CTK()`
`67`	`69`	`};`
`68`	`70`	`struct normal`
`69`	`71`	`{`
	`72`	`+#if _CCCL_HAS_CTK()`
`70`	`73`	`[[nodiscard]] _LIBCUDACXX_HIDE_FROM_ABI constexpr operator cudaAccessProperty() const noexcept`
`71`	`74`	`{`
`72`	`75`	`return cudaAccessProperty::cudaAccessPropertyNormal;`
`73`	`76`	`}`
	`77`	`+#endif // _CCCL_HAS_CTK()`
`74`	`78`	`};`
`75`	`79`
`76`	`80`	`_CCCL_HIDE_FROM_ABI access_property() noexcept = default;`
Original file line number	Diff line number	Diff line change
`@@ -21,10 +21,6 @@`
`21`	`21`	`# pragma system_header`
`22`	`22`	`#endif // no system header`
`23`	`23`
`24`		`-#if !_CCCL_HAS_CUDA_COMPILER \|\| _CCCL_CUDA_COMPILER(CLANG)`
`25`		`-# include <cuda_runtime_api.h>`
`26`		`-#endif // _CCCL_CUDA_COMPILER(CLANG)`
`27`		`-`
`28`	`24`	`#include <cuda/std/__concepts/concept_macros.h>`
`29`	`25`	`#include <cuda/std/__cuda/api_wrapper.h>`
`30`	`26`	`#include <cuda/std/__iterator/concepts.h>`
`@@ -107,6 +103,7 @@ class __host_accessor : public _Accessor`
`107`	`103`	`[[nodiscard]] _LIBCUDACXX_HIDE_FROM_ABI static constexpr bool`
`108`	`104`	`__is_host_accessible_pointer([[maybe_unused]] __data_handle_type __p) noexcept`
`109`	`105`	`{`
	`106`	`+#if _CCCL_HAS_CTK()`
`110`	`107`	`if constexpr (_CUDA_VSTD::contiguous_iterator<__data_handle_type>)`
`111`	`108`	`{`
`112`	`109`	`::cudaPointerAttributes __ptr_attrib{};`
`@@ -115,6 +112,7 @@ class __host_accessor : public _Accessor`
`115`	`112`	`return __ptr_attrib.hostPointer != nullptr \|\| __ptr_attrib.type == ::cudaMemoryTypeUnregistered;`
`116`	`113`	`}`
`117`	`114`	`else`
	`115`	`+#endif // _CCCL_HAS_CTK()`
`118`	`116`	`{`
`119`	`117`	`return true; // cannot be verified`
`120`	`118`	`}`
`@@ -222,6 +220,7 @@ class __device_accessor : public _Accessor`
`222`	`220`	`[[nodiscard]] _LIBCUDACXX_HIDE_FROM_ABI static constexpr bool`
`223`	`221`	`__is_device_accessible_pointer([[maybe_unused]] __data_handle_type __p) noexcept`
`224`	`222`	`{`
	`223`	`+#if _CCCL_HAS_CTK()`
`225`	`224`	`if constexpr (_CUDA_VSTD::contiguous_iterator<__data_handle_type>)`
`226`	`225`	`{`
`227`	`226`	`::cudaPointerAttributes __ptr_attrib{};`
`@@ -230,6 +229,7 @@ class __device_accessor : public _Accessor`
`230`	`229`	`return __ptr_attrib.devicePointer != nullptr \|\| __ptr_attrib.type == ::cudaMemoryTypeUnregistered;`
`231`	`230`	`}`
`232`	`231`	`else`
	`232`	`+#endif // _CCCL_HAS_CTK()`
`233`	`233`	`{`
`234`	`234`	`return true; // cannot be verified`
`235`	`235`	`}`
`@@ -342,6 +342,7 @@ class __managed_accessor : public _Accessor`
`342`	`342`	`[[nodiscard]] _LIBCUDACXX_HIDE_FROM_ABI static constexpr bool`
`343`	`343`	`__is_managed_pointer([[maybe_unused]] __data_handle_type __p) noexcept`
`344`	`344`	`{`
	`345`	`+#if _CCCL_HAS_CTK()`
`345`	`346`	`if constexpr (_CUDA_VSTD::contiguous_iterator<__data_handle_type>)`
`346`	`347`	`{`
`347`	`348`	`::cudaPointerAttributes __ptr_attrib{};`
`@@ -350,6 +351,7 @@ class __managed_accessor : public _Accessor`
`350`	`351`	`return __ptr_attrib.devicePointer != nullptr && __ptr_attrib.hostPointer == __ptr_attrib.devicePointer;`
`351`	`352`	`}`
`352`	`353`	`else`
	`354`	`+#endif // _CCCL_HAS_CTK()`
`353`	`355`	`{`
`354`	`356`	`return true; // cannot be verified`
`355`	`357`	`}`