Change _CUDAX_GET_DRIVER_FUNCTION and minor fixes

Author: pciolkosz

cudax/include/cuda/experimental/__driver/driver_api.cuh

@@ -27,16 +27,18 @@
 #  include <cuda/std/cstddef>
 
 #  include <cuda.h>
+#  include <cudaTypedefs.h>
 
 #  include <cuda/std/__cccl/prologue.h>
 
-// Redefine the macros locally — they are #undef'd at the end of driver_api.h.
-#  define _CUDAX_GET_DRIVER_FUNCTION(function_name) \
-    reinterpret_cast<decltype(::function_name)*>(::cuda::__driver::__get_driver_entry_point(#function_name))
-
-#  define _CUDAX_GET_DRIVER_FUNCTION_VERSIONED(function_name, versioned_fn_name, major, minor) \
-    reinterpret_cast<decltype(::versioned_fn_name)*>(                                          \
-      ::cuda::__driver::__get_driver_entry_point(#function_name, major, minor))
+// Get a driver function pointer, casting to the PFN typedef for type safety.
+// Uses PFN_ typedefs from cudaTypedefs.h to avoid ABI mismatches caused by
+// #define'd version aliases in cuda.h (e.g. #define cuFoo cuFoo_v2).
+// The ## operator suppresses macro expansion of the function name, so this is
+// safe even for names that are #define'd to versioned variants.
+#  define _CUDAX_GET_DRIVER_FUNCTION(pfn_name, major, minor)                                    \
+    reinterpret_cast<PFN_##pfn_name##_v##major##0##minor##0>(                                   \
+      ::cuda::__driver::__get_driver_entry_point(#pfn_name, major, minor))
 
 namespace cuda::experimental::__driver
 {
@@ -53,7 +55,7 @@ namespace cuda::experimental::__driver
   ::cuda::std::size_t __width,
   ::cuda::std::size_t __height)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddMemsetNode);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddMemsetNode, 10, 0);
   ::CUgraphNode __node{};
   ::CUDA_MEMSET_NODE_PARAMS __params{};
   __params.dst         = __dst;
@@ -78,7 +80,7 @@ namespace cuda::experimental::__driver
   ::CUdeviceptr __src,
   ::cuda::std::size_t __byte_count)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddMemcpyNode);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddMemcpyNode, 10, 0);
   ::CUgraphNode __node{};
   ::CUDA_MEMCPY3D __params{};
   __params.srcMemoryType = ::CU_MEMORYTYPE_UNIFIED;
@@ -99,7 +101,7 @@ namespace cuda::experimental::__driver
 [[nodiscard]] _CCCL_HOST_API inline ::CUgraphNode __graphAddHostNode(
   ::CUgraph __graph, const ::CUgraphNode* __deps, ::cuda::std::size_t __ndeps, ::CUhostFn __fn, void* __user_data)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddHostNode);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddHostNode, 10, 0);
   ::CUgraphNode __node{};
   ::CUDA_HOST_NODE_PARAMS __params{};
   __params.fn       = __fn;
@@ -114,7 +116,7 @@ namespace cuda::experimental::__driver
 [[nodiscard]] _CCCL_HOST_API inline ::CUgraphNode __graphAddChildGraphNode(
   ::CUgraph __graph, const ::CUgraphNode* __deps, ::cuda::std::size_t __ndeps, ::CUgraph __child_graph)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddChildGraphNode);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddChildGraphNode, 10, 0);
   ::CUgraphNode __node{};
   ::cuda::__driver::__call_driver_fn(
     __driver_fn, "Failed to add a child graph node", &__node, __graph, __deps, __ndeps, __child_graph);
@@ -124,24 +126,24 @@ namespace cuda::experimental::__driver
 // ── Graph: event record node ────────────────────────────────────────────────
 
 [[nodiscard]] _CCCL_HOST_API inline ::CUgraphNode __graphAddEventRecordNode(
-  ::CUgraph __graph, const ::CUgraphNode* __deps, ::cuda::std::size_t __ndeps, ::CUevent __event)
+  ::CUgraph __graph, const ::CUgraphNode* __deps, ::cuda::std::size_t __ndeps, ::CUevent __ev)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddEventRecordNode);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddEventRecordNode, 11, 1);
   ::CUgraphNode __node{};
   ::cuda::__driver::__call_driver_fn(
-    __driver_fn, "Failed to add an event record node to graph", &__node, __graph, __deps, __ndeps, __event);
+    __driver_fn, "Failed to add an event record node to graph", &__node, __graph, __deps, __ndeps, __ev);
   return __node;
 }
 
 // ── Graph: event wait node ──────────────────────────────────────────────────
 
 [[nodiscard]] _CCCL_HOST_API inline ::CUgraphNode
-__graphAddEventWaitNode(::CUgraph __graph, const ::CUgraphNode* __deps, ::cuda::std::size_t __ndeps, ::CUevent __event)
+__graphAddEventWaitNode(::CUgraph __graph, const ::CUgraphNode* __deps, ::cuda::std::size_t __ndeps, ::CUevent __ev)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddEventWaitNode);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddEventWaitNode, 11, 1);
   ::CUgraphNode __node{};
   ::cuda::__driver::__call_driver_fn(
-    __driver_fn, "Failed to add an event wait node to graph", &__node, __graph, __deps, __ndeps, __event);
+    __driver_fn, "Failed to add an event wait node to graph", &__node, __graph, __deps, __ndeps, __ev);
   return __node;
 }
 
@@ -152,7 +154,7 @@ __graphAddEventWaitNode(::CUgraph __graph, const ::CUgraphNode* __deps, ::cuda::
 [[nodiscard]] _CCCL_HOST_API inline ::CUgraphConditionalHandle
 __graphConditionalHandleCreate(::CUgraph __graph, unsigned int __default_val, unsigned int __flags)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphConditionalHandleCreate);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphConditionalHandleCreate, 12, 3);
   ::CUgraphConditionalHandle __handle{};
   ::CUcontext __ctx = ::cuda::__driver::__ctxGetCurrent();
   ::cuda::__driver::__call_driver_fn(
@@ -165,7 +167,7 @@ __graphConditionalHandleCreate(::CUgraph __graph, unsigned int __default_val, un
 [[nodiscard]] _CCCL_HOST_API inline ::CUgraphNode __graphAddNode(
   ::CUgraph __graph, const ::CUgraphNode* __deps, ::cuda::std::size_t __ndeps, ::CUgraphNodeParams* __params)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddNode);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddNode, 12, 2);
   ::CUgraphNode __node{};
   ::cuda::__driver::__call_driver_fn(
     __driver_fn, "Failed to add a node to graph", &__node, __graph, __deps, __ndeps, __params);
@@ -178,7 +180,7 @@ __graphConditionalHandleCreate(::CUgraph __graph, unsigned int __default_val, un
 
 [[nodiscard]] _CCCL_HOST_API inline ::CUgraph __graphCreate()
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphCreate);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphCreate, 10, 0);
   ::CUgraph __graph{};
   ::cuda::__driver::__call_driver_fn(__driver_fn, "Failed to create graph", &__graph, 0u);
   return __graph;
@@ -188,15 +190,15 @@ __graphConditionalHandleCreate(::CUgraph __graph, unsigned int __default_val, un
 
 [[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __graphDestroyNoThrow(::CUgraph __graph) noexcept
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphDestroy);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphDestroy, 10, 0);
   return static_cast<::cudaError_t>(__driver_fn(__graph));
 }
 
 // ── Graph: clone ────────────────────────────────────────────────────────────
 
 [[nodiscard]] _CCCL_HOST_API inline ::CUgraph __graphClone(::CUgraph __original)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphClone);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphClone, 10, 0);
   ::CUgraph __clone{};
   ::cuda::__driver::__call_driver_fn(__driver_fn, "Failed to clone graph", &__clone, __original);
   return __clone;
@@ -206,7 +208,7 @@ __graphConditionalHandleCreate(::CUgraph __graph, unsigned int __default_val, un
 
 [[nodiscard]] _CCCL_HOST_API inline ::cuda::std::size_t __graphGetNodeCount(::CUgraph __graph)
 {
-  static auto __driver_fn     = _CUDAX_GET_DRIVER_FUNCTION(cuGraphGetNodes);
+  static auto __driver_fn     = _CUDAX_GET_DRIVER_FUNCTION(cuGraphGetNodes, 10, 0);
   ::cuda::std::size_t __count = 0;
   ::cuda::__driver::__call_driver_fn(__driver_fn, "Failed to get graph node count", __graph, nullptr, &__count);
   return __count;
@@ -216,7 +218,7 @@ __graphConditionalHandleCreate(::CUgraph __graph, unsigned int __default_val, un
 
 [[nodiscard]] _CCCL_HOST_API inline ::CUgraphExec __graphInstantiate(::CUgraph __graph, unsigned long long __flags = 0)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphInstantiate);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphInstantiateWithFlags, 11, 4);
   ::CUgraphExec __exec{};
   ::cuda::__driver::__call_driver_fn(__driver_fn, "Failed to instantiate graph", &__exec, __graph, __flags);
   return __exec;
@@ -226,15 +228,15 @@ __graphConditionalHandleCreate(::CUgraph __graph, unsigned int __default_val, un
 
 _CCCL_HOST_API inline void __graphLaunch(::CUgraphExec __exec, ::CUstream __stream)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphLaunch);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphLaunch, 10, 0);
   ::cuda::__driver::__call_driver_fn(__driver_fn, "Failed to launch graph", __exec, __stream);
 }
 
 // ── Graph exec: destroy (no-throw, for use in destructors) ──────────────────
 
 [[nodiscard]] _CCCL_HOST_API inline ::cudaError_t __graphExecDestroyNoThrow(::CUgraphExec __exec) noexcept
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphExecDestroy);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphExecDestroy, 10, 0);
   return static_cast<::cudaError_t>(__driver_fn(__exec));
 }
 
@@ -243,7 +245,7 @@ _CCCL_HOST_API inline void __graphLaunch(::CUgraphExec __exec, ::CUstream __stre
 [[nodiscard]] _CCCL_HOST_API inline ::CUgraphNode
 __graphAddEmptyNode(::CUgraph __graph, const ::CUgraphNode* __deps, ::cuda::std::size_t __ndeps)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddEmptyNode);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddEmptyNode, 10, 0);
   ::CUgraphNode __node{};
   ::cuda::__driver::__call_driver_fn(
     __driver_fn, "Failed to add an empty node to graph", &__node, __graph, __deps, __ndeps);
@@ -256,26 +258,32 @@ _CCCL_HOST_API inline void __graphAddDependencies(
   ::CUgraph __graph,
   const ::CUgraphNode* __from,
   const ::CUgraphNode* __to,
-  ::cuda::std::size_t __ndeps,
-  const ::CUgraphEdgeData* __edge_data = nullptr)
+  ::cuda::std::size_t __ndeps)
 {
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddDependencies, 10, 0);
+  ::cuda::__driver::__call_driver_fn(__driver_fn, "Failed to add graph dependencies", __graph, __from, __to, __ndeps);
+}
+
 #  if _CCCL_CTK_AT_LEAST(12, 3)
+_CCCL_HOST_API inline void __graphAddDependencies(
+  ::CUgraph __graph,
+  const ::CUgraphNode* __from,
+  const ::CUgraphNode* __to,
+  ::cuda::std::size_t __ndeps,
+  const ::CUgraphEdgeData* __edge_data)
+{
   static auto __driver_fn =
-    _CUDAX_GET_DRIVER_FUNCTION_VERSIONED(cuGraphAddDependencies, cuGraphAddDependencies_v2, 12, 3);
+    _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddDependencies, 12, 3);
   ::cuda::__driver::__call_driver_fn(
     __driver_fn, "Failed to add graph dependencies", __graph, __from, __to, __edge_data, __ndeps);
-#  else
-  _CCCL_ASSERT(__edge_data == nullptr, "Edge data requires CUDA Toolkit 12.3 or later");
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphAddDependencies);
-  ::cuda::__driver::__call_driver_fn(__driver_fn, "Failed to add graph dependencies", __graph, __from, __to, __ndeps);
-#  endif
 }
+#  endif // _CCCL_CTK_AT_LEAST(12, 3)
 
 // ── Graph node: get type ────────────────────────────────────────────────────
 
 [[nodiscard]] _CCCL_HOST_API inline ::CUgraphNodeType __graphNodeGetType(::CUgraphNode __node)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphNodeGetType);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuGraphNodeGetType, 10, 0);
   ::CUgraphNodeType __type{};
   ::cuda::__driver::__call_driver_fn(__driver_fn, "Failed to get graph node type", __node, &__type);
   return __type;
@@ -292,7 +300,8 @@ _CCCL_HOST_API inline void __streamBeginCaptureToGraph(
   ::cuda::std::size_t __ndeps,
   ::CUstreamCaptureMode __mode)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuStreamBeginCaptureToGraph);
+  static auto __driver_fn =
+    _CUDAX_GET_DRIVER_FUNCTION(cuStreamBeginCaptureToGraph, 12, 3);
   ::cuda::__driver::__call_driver_fn(
     __driver_fn, "Failed to begin stream capture to graph", __stream, __graph, __deps, nullptr, __ndeps, __mode);
 }
@@ -313,7 +322,7 @@ __streamGetCaptureInfo(::CUstream __stream, const ::CUgraphEdgeData** __edge_dat
   __stream_capture_info __info{};
 #    if _CCCL_CTK_AT_LEAST(12, 4)
   static auto __driver_fn =
-    _CUDAX_GET_DRIVER_FUNCTION_VERSIONED(cuStreamGetCaptureInfo, cuStreamGetCaptureInfo_v3, 12, 4);
+    _CUDAX_GET_DRIVER_FUNCTION(cuStreamGetCaptureInfo, 12, 3);
   ::cuda::__driver::__call_driver_fn(
     __driver_fn,
     "Failed to get stream capture info",
@@ -327,7 +336,8 @@ __streamGetCaptureInfo(::CUstream __stream, const ::CUgraphEdgeData** __edge_dat
 #    else
   _CCCL_ASSERT(__edge_data_out == nullptr, "Edge data requires CUDA Toolkit 12.4 or later");
   __info.__edge_data      = nullptr;
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuStreamGetCaptureInfo);
+  static auto __driver_fn =
+    _CUDAX_GET_DRIVER_FUNCTION(cuStreamGetCaptureInfo, 11, 3);
   ::cuda::__driver::__call_driver_fn(
     __driver_fn,
     "Failed to get stream capture info",
@@ -345,15 +355,14 @@ __streamGetCaptureInfo(::CUstream __stream, const ::CUgraphEdgeData** __edge_dat
 
 _CCCL_HOST_API inline void __streamEndCapture(::CUstream __stream, ::CUgraph* __graph_out)
 {
-  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuStreamEndCapture);
+  static auto __driver_fn = _CUDAX_GET_DRIVER_FUNCTION(cuStreamEndCapture, 10, 0);
   ::cuda::__driver::__call_driver_fn(__driver_fn, "Failed to end stream capture", __stream, __graph_out);
 }
 
 #  endif // _CCCL_CTK_AT_LEAST(12, 3)
 } // namespace cuda::experimental::__driver
 
 #  undef _CUDAX_GET_DRIVER_FUNCTION
-#  undef _CUDAX_GET_DRIVER_FUNCTION_VERSIONED
 
 #  include <cuda/std/__cccl/epilogue.h>
 

libcudacxx/include/cuda/__driver/driver_api.h

@@ -95,7 +95,7 @@ _CCCL_SUPPRESS_DEPRECATED_POP
 //! @brief Makes the driver version from major and minor version.
 [[nodiscard]] _CCCL_HOST_API constexpr int __make_version(int __major, int __minor) noexcept
 {
-  _CCCL_ASSERT(__major >= 12, "invalid major CUDA Driver version");
+  _CCCL_ASSERT(__major >= 2, "invalid major CUDA Driver version");
   _CCCL_ASSERT(__minor >= 0 && __minor < 100, "invalid minor CUDA Driver version");
   return __major * 1000 + __minor * 10;
 }