Remove CUDA symbols from pre-generated bindings

Author: yan-zaretskiy

rust/cuvs-sys/bindgen-stubs/cuda_runtime.h

@@ -0,0 +1,17 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#pragma once
+
+/*
+ * Minimal bindgen-only CUDA runtime stub.
+ *
+ * cuVS C headers currently include <cuda_runtime.h> only for cudaStream_t and
+ * cudaDataType_t in public C ABI declarations. The Rust bindings provide their
+ * own ABI-compatible definitions and blocklist CUDA items, so bindgen only needs
+ * these declarations to parse the headers without having to discover a CUDA Toolkit.
+ */
+typedef struct CUstream_st* cudaStream_t;
+typedef unsigned int cudaDataType_t;

rust/cuvs-sys/build.rs

@@ -9,31 +9,28 @@ mod cmake;
 use std::path::{Path, PathBuf};
 
 #[cfg(feature = "generate-bindings")]
-fn generate_bindings(
-    include_dir: &Path,
-    include_dirs: &[PathBuf],
-    system_include_dirs: &[PathBuf],
-) {
+fn generate_bindings(include_dir: &Path, include_dirs: &[PathBuf]) {
     let out_dir = PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR not set by Cargo"));
+    let stub_dir = Path::new(env!("CARGO_MANIFEST_DIR")).join("bindgen-stubs");
 
     let mut builder = bindgen::Builder::default()
         .header("cuvs_c_wrapper.h")
         .must_use_type("cuvsError_t")
-        .allowlist_function("(cuvs|cudaMemcpyAsync).*")
-        .allowlist_type("(cuvs|DL|cudaError|cudaMemcpyKind).*")
-        .rustified_enum("(cuvs|DL|cudaError).*")
+        .allowlist_function("cuvs.*")
+        .allowlist_type("(cuvs|DL).*")
+        .rustified_enum("(cuvs|DL).*")
+        .blocklist_item("cuda.*")
+        .blocklist_item("CUstream_st")
+        .raw_line("use crate::{cudaDataType_t, cudaStream_t};")
         .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()));
 
+    builder = builder.clang_arg(format!("-I{}", stub_dir.display()));
     builder = builder.clang_arg(format!("-I{}", include_dir.display()));
 
     for include_dir in include_dirs {
         builder = builder.clang_arg(format!("-I{}", include_dir.display()));
     }
 
-    for include_dir in system_include_dirs {
-        builder = builder.clang_arg(format!("-isystem{}", include_dir.display()));
-    }
-
     builder
         .generate()
         .expect("bindgen failed to generate cuvs bindings")
@@ -44,6 +41,7 @@ fn generate_bindings(
 fn main() {
     println!("cargo::rerun-if-changed=cmake.rs");
     println!("cargo::rerun-if-changed=cmake/find_cuvs.cmake");
+    println!("cargo::rerun-if-changed=bindgen-stubs/cuda_runtime.h");
     println!("cargo::rerun-if-env-changed=CMAKE_PREFIX_PATH");
     println!("cargo::rerun-if-env-changed=CONDA_PREFIX");
     println!("cargo::rerun-if-env-changed=LIBCUVS_USE_PYTHON");
@@ -61,19 +59,11 @@ fn main() {
         }
     };
 
-    // The bindings expose cudaMemcpyAsync which lives in libcudart,
-    // not in libcuvs_c, so we must link it explicitly.
-    println!("cargo:rustc-link-lib=dylib=cudart");
-
     // Expose include path to downstream crates via DEP_CUVS_INCLUDE.
     println!("cargo::metadata=include={}", metadata.include_dir.display());
     // Expose the directory containing libcuvs_c.so via DEP_CUVS_LIB.
     println!("cargo::metadata=lib={}", metadata.lib_dir.display());
 
     #[cfg(feature = "generate-bindings")]
-    generate_bindings(
-        &metadata.include_dir,
-        &metadata.bindgen_include_dirs,
-        &metadata.bindgen_system_include_dirs,
-    );
+    generate_bindings(&metadata.include_dir, &metadata.bindgen_include_dirs);
 }

rust/cuvs-sys/cmake.rs

@@ -30,8 +30,6 @@ pub(crate) struct CuvsMetadata {
     pub(crate) include_dir: PathBuf,
     #[cfg(feature = "generate-bindings")]
     pub(crate) bindgen_include_dirs: Vec<PathBuf>,
-    #[cfg(feature = "generate-bindings")]
-    pub(crate) bindgen_system_include_dirs: Vec<PathBuf>,
     pub(crate) lib_dir: PathBuf,
 }
 
@@ -165,19 +163,6 @@ fn find_cuvs_package(cmake_dir: &Path) -> Result<cmake_package::CMakePackage> {
         })
 }
 
-#[cfg(feature = "generate-bindings")]
-fn find_cudatoolkit_package() -> Result<cmake_package::CMakePackage> {
-    find_package("CUDAToolkit").find().map_err(|e| match e {
-        CmakeError::CMakeNotFound | CmakeError::UnsupportedCMakeVersion => {
-            cmake_unavailable_error()
-        }
-        _ => anyhow::anyhow!(
-            "Could not find CUDA Toolkit CMake package.\n\n\
-             Install CUDA Toolkit so that `find_package(CUDAToolkit)` succeeds."
-        ),
-    })
-}
-
 #[cfg(feature = "generate-bindings")]
 fn find_dlpack_package() -> Result<cmake_package::CMakePackage> {
     find_package("dlpack").find().map_err(|e| match e {
@@ -216,7 +201,7 @@ pub(crate) fn try_find_cuvs_package(
         .map(PathBuf::from)
         .context("cuVS CMake target did not export any include directories")?;
 
-    // CUDAToolkit and DLPack include directories are only needed for bindgen.
+    // DLPack include directories are only needed for bindgen.
     #[cfg(feature = "generate-bindings")]
     let bindgen_include_dirs: Vec<_> = {
         let dlpack = find_dlpack_package()?;
@@ -230,18 +215,6 @@ pub(crate) fn try_find_cuvs_package(
             .collect()
     };
 
-    #[cfg(feature = "generate-bindings")]
-    let bindgen_system_include_dirs: Vec<_> = {
-        let cudatoolkit = find_cudatoolkit_package()?;
-        let cudatoolkit_target = find_target(&cudatoolkit, "CUDA::toolkit")?;
-        cudatoolkit_target
-            .include_directories
-            .iter()
-            .map(PathBuf::from)
-            .filter(|dir| dir.is_dir())
-            .collect()
-    };
-
     let lib_dir = target
         .location
         .as_deref()
@@ -256,8 +229,6 @@ pub(crate) fn try_find_cuvs_package(
         include_dir,
         #[cfg(feature = "generate-bindings")]
         bindgen_include_dirs,
-        #[cfg(feature = "generate-bindings")]
-        bindgen_system_include_dirs,
         lib_dir,
     })
 }

rust/cuvs-sys/src/bindings.rs

@@ -1,202 +1,7 @@
 /* automatically generated by rust-bindgen 0.72.1 */
 
-#[repr(u32)]
-#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub enum cudaError {
-    cudaSuccess = 0,
-    cudaErrorInvalidValue = 1,
-    cudaErrorMemoryAllocation = 2,
-    cudaErrorInitializationError = 3,
-    cudaErrorCudartUnloading = 4,
-    cudaErrorProfilerDisabled = 5,
-    cudaErrorProfilerNotInitialized = 6,
-    cudaErrorProfilerAlreadyStarted = 7,
-    cudaErrorProfilerAlreadyStopped = 8,
-    cudaErrorInvalidConfiguration = 9,
-    cudaErrorInvalidPitchValue = 12,
-    cudaErrorInvalidSymbol = 13,
-    cudaErrorInvalidHostPointer = 16,
-    cudaErrorInvalidDevicePointer = 17,
-    cudaErrorInvalidTexture = 18,
-    cudaErrorInvalidTextureBinding = 19,
-    cudaErrorInvalidChannelDescriptor = 20,
-    cudaErrorInvalidMemcpyDirection = 21,
-    cudaErrorAddressOfConstant = 22,
-    cudaErrorTextureFetchFailed = 23,
-    cudaErrorTextureNotBound = 24,
-    cudaErrorSynchronizationError = 25,
-    cudaErrorInvalidFilterSetting = 26,
-    cudaErrorInvalidNormSetting = 27,
-    cudaErrorMixedDeviceExecution = 28,
-    cudaErrorNotYetImplemented = 31,
-    cudaErrorMemoryValueTooLarge = 32,
-    cudaErrorStubLibrary = 34,
-    cudaErrorInsufficientDriver = 35,
-    cudaErrorCallRequiresNewerDriver = 36,
-    cudaErrorInvalidSurface = 37,
-    cudaErrorDuplicateVariableName = 43,
-    cudaErrorDuplicateTextureName = 44,
-    cudaErrorDuplicateSurfaceName = 45,
-    cudaErrorDevicesUnavailable = 46,
-    cudaErrorIncompatibleDriverContext = 49,
-    cudaErrorMissingConfiguration = 52,
-    cudaErrorPriorLaunchFailure = 53,
-    cudaErrorLaunchMaxDepthExceeded = 65,
-    cudaErrorLaunchFileScopedTex = 66,
-    cudaErrorLaunchFileScopedSurf = 67,
-    cudaErrorSyncDepthExceeded = 68,
-    cudaErrorLaunchPendingCountExceeded = 69,
-    cudaErrorInvalidDeviceFunction = 98,
-    cudaErrorNoDevice = 100,
-    cudaErrorInvalidDevice = 101,
-    cudaErrorDeviceNotLicensed = 102,
-    cudaErrorSoftwareValidityNotEstablished = 103,
-    cudaErrorStartupFailure = 127,
-    cudaErrorInvalidKernelImage = 200,
-    cudaErrorDeviceUninitialized = 201,
-    cudaErrorMapBufferObjectFailed = 205,
-    cudaErrorUnmapBufferObjectFailed = 206,
-    cudaErrorArrayIsMapped = 207,
-    cudaErrorAlreadyMapped = 208,
-    cudaErrorNoKernelImageForDevice = 209,
-    cudaErrorAlreadyAcquired = 210,
-    cudaErrorNotMapped = 211,
-    cudaErrorNotMappedAsArray = 212,
-    cudaErrorNotMappedAsPointer = 213,
-    cudaErrorECCUncorrectable = 214,
-    cudaErrorUnsupportedLimit = 215,
-    cudaErrorDeviceAlreadyInUse = 216,
-    cudaErrorPeerAccessUnsupported = 217,
-    cudaErrorInvalidPtx = 218,
-    cudaErrorInvalidGraphicsContext = 219,
-    cudaErrorNvlinkUncorrectable = 220,
-    cudaErrorJitCompilerNotFound = 221,
-    cudaErrorUnsupportedPtxVersion = 222,
-    cudaErrorJitCompilationDisabled = 223,
-    cudaErrorUnsupportedExecAffinity = 224,
-    cudaErrorUnsupportedDevSideSync = 225,
-    cudaErrorContained = 226,
-    cudaErrorInvalidSource = 300,
-    cudaErrorFileNotFound = 301,
-    cudaErrorSharedObjectSymbolNotFound = 302,
-    cudaErrorSharedObjectInitFailed = 303,
-    cudaErrorOperatingSystem = 304,
-    cudaErrorInvalidResourceHandle = 400,
-    cudaErrorIllegalState = 401,
-    cudaErrorLossyQuery = 402,
-    cudaErrorSymbolNotFound = 500,
-    cudaErrorNotReady = 600,
-    cudaErrorIllegalAddress = 700,
-    cudaErrorLaunchOutOfResources = 701,
-    cudaErrorLaunchTimeout = 702,
-    cudaErrorLaunchIncompatibleTexturing = 703,
-    cudaErrorPeerAccessAlreadyEnabled = 704,
-    cudaErrorPeerAccessNotEnabled = 705,
-    cudaErrorSetOnActiveProcess = 708,
-    cudaErrorContextIsDestroyed = 709,
-    cudaErrorAssert = 710,
-    cudaErrorTooManyPeers = 711,
-    cudaErrorHostMemoryAlreadyRegistered = 712,
-    cudaErrorHostMemoryNotRegistered = 713,
-    cudaErrorHardwareStackError = 714,
-    cudaErrorIllegalInstruction = 715,
-    cudaErrorMisalignedAddress = 716,
-    cudaErrorInvalidAddressSpace = 717,
-    cudaErrorInvalidPc = 718,
-    cudaErrorLaunchFailure = 719,
-    cudaErrorCooperativeLaunchTooLarge = 720,
-    cudaErrorTensorMemoryLeak = 721,
-    cudaErrorNotPermitted = 800,
-    cudaErrorNotSupported = 801,
-    cudaErrorSystemNotReady = 802,
-    cudaErrorSystemDriverMismatch = 803,
-    cudaErrorCompatNotSupportedOnDevice = 804,
-    cudaErrorMpsConnectionFailed = 805,
-    cudaErrorMpsRpcFailure = 806,
-    cudaErrorMpsServerNotReady = 807,
-    cudaErrorMpsMaxClientsReached = 808,
-    cudaErrorMpsMaxConnectionsReached = 809,
-    cudaErrorMpsClientTerminated = 810,
-    cudaErrorCdpNotSupported = 811,
-    cudaErrorCdpVersionMismatch = 812,
-    cudaErrorStreamCaptureUnsupported = 900,
-    cudaErrorStreamCaptureInvalidated = 901,
-    cudaErrorStreamCaptureMerge = 902,
-    cudaErrorStreamCaptureUnmatched = 903,
-    cudaErrorStreamCaptureUnjoined = 904,
-    cudaErrorStreamCaptureIsolation = 905,
-    cudaErrorStreamCaptureImplicit = 906,
-    cudaErrorCapturedEvent = 907,
-    cudaErrorStreamCaptureWrongThread = 908,
-    cudaErrorTimeout = 909,
-    cudaErrorGraphExecUpdateFailure = 910,
-    cudaErrorExternalDevice = 911,
-    cudaErrorInvalidClusterSize = 912,
-    cudaErrorFunctionNotLoaded = 913,
-    cudaErrorInvalidResourceType = 914,
-    cudaErrorInvalidResourceConfiguration = 915,
-    cudaErrorStreamDetached = 917,
-    cudaErrorUnknown = 999,
-    cudaErrorApiFailureBase = 10000,
-}
-pub const cudaMemcpyKind_cudaMemcpyHostToHost: cudaMemcpyKind = 0;
-pub const cudaMemcpyKind_cudaMemcpyHostToDevice: cudaMemcpyKind = 1;
-pub const cudaMemcpyKind_cudaMemcpyDeviceToHost: cudaMemcpyKind = 2;
-pub const cudaMemcpyKind_cudaMemcpyDeviceToDevice: cudaMemcpyKind = 3;
-pub const cudaMemcpyKind_cudaMemcpyDefault: cudaMemcpyKind = 4;
-pub type cudaMemcpyKind = ::std::os::raw::c_uint;
-pub use self::cudaError as cudaError_t;
-#[repr(C)]
-#[derive(Debug, Copy, Clone)]
-pub struct CUstream_st {
-    _unused: [u8; 0],
-}
-pub type cudaStream_t = *mut CUstream_st;
-pub const cudaDataType_t_CUDA_R_16F: cudaDataType_t = 2;
-pub const cudaDataType_t_CUDA_C_16F: cudaDataType_t = 6;
-pub const cudaDataType_t_CUDA_R_16BF: cudaDataType_t = 14;
-pub const cudaDataType_t_CUDA_C_16BF: cudaDataType_t = 15;
-pub const cudaDataType_t_CUDA_R_32F: cudaDataType_t = 0;
-pub const cudaDataType_t_CUDA_C_32F: cudaDataType_t = 4;
-pub const cudaDataType_t_CUDA_R_64F: cudaDataType_t = 1;
-pub const cudaDataType_t_CUDA_C_64F: cudaDataType_t = 5;
-pub const cudaDataType_t_CUDA_R_4I: cudaDataType_t = 16;
-pub const cudaDataType_t_CUDA_C_4I: cudaDataType_t = 17;
-pub const cudaDataType_t_CUDA_R_4U: cudaDataType_t = 18;
-pub const cudaDataType_t_CUDA_C_4U: cudaDataType_t = 19;
-pub const cudaDataType_t_CUDA_R_8I: cudaDataType_t = 3;
-pub const cudaDataType_t_CUDA_C_8I: cudaDataType_t = 7;
-pub const cudaDataType_t_CUDA_R_8U: cudaDataType_t = 8;
-pub const cudaDataType_t_CUDA_C_8U: cudaDataType_t = 9;
-pub const cudaDataType_t_CUDA_R_16I: cudaDataType_t = 20;
-pub const cudaDataType_t_CUDA_C_16I: cudaDataType_t = 21;
-pub const cudaDataType_t_CUDA_R_16U: cudaDataType_t = 22;
-pub const cudaDataType_t_CUDA_C_16U: cudaDataType_t = 23;
-pub const cudaDataType_t_CUDA_R_32I: cudaDataType_t = 10;
-pub const cudaDataType_t_CUDA_C_32I: cudaDataType_t = 11;
-pub const cudaDataType_t_CUDA_R_32U: cudaDataType_t = 12;
-pub const cudaDataType_t_CUDA_C_32U: cudaDataType_t = 13;
-pub const cudaDataType_t_CUDA_R_64I: cudaDataType_t = 24;
-pub const cudaDataType_t_CUDA_C_64I: cudaDataType_t = 25;
-pub const cudaDataType_t_CUDA_R_64U: cudaDataType_t = 26;
-pub const cudaDataType_t_CUDA_C_64U: cudaDataType_t = 27;
-pub const cudaDataType_t_CUDA_R_8F_E4M3: cudaDataType_t = 28;
-pub const cudaDataType_t_CUDA_R_8F_UE4M3: cudaDataType_t = 28;
-pub const cudaDataType_t_CUDA_R_8F_E5M2: cudaDataType_t = 29;
-pub const cudaDataType_t_CUDA_R_8F_UE8M0: cudaDataType_t = 30;
-pub const cudaDataType_t_CUDA_R_6F_E2M3: cudaDataType_t = 31;
-pub const cudaDataType_t_CUDA_R_6F_E3M2: cudaDataType_t = 32;
-pub const cudaDataType_t_CUDA_R_4F_E2M1: cudaDataType_t = 33;
-pub type cudaDataType_t = ::std::os::raw::c_uint;
-unsafe extern "C" {
-    pub fn cudaMemcpyAsync(
-        dst: *mut ::std::os::raw::c_void,
-        src: *const ::std::os::raw::c_void,
-        count: usize,
-        kind: cudaMemcpyKind,
-        stream: cudaStream_t,
-    ) -> cudaError_t;
-}
+use crate::{cudaDataType_t, cudaStream_t};
+
 #[repr(u32)]
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub enum DLDeviceType {
@@ -779,7 +584,6 @@ unsafe extern "C" {
 }
 #[doc = " @defgroup ivf_pq_c_search_params IVF-PQ index search parameters\n @{\n/\n/**\n @brief Supplemental parameters to search IVF-PQ index\n"]
 #[repr(C)]
-#[derive(Debug, Copy, Clone)]
 pub struct cuvsIvfPqSearchParams {
     #[doc = " The number of clusters to search."]
     pub n_probes: u32,