feat: Make qdp-kernels build/link on Linux without nvcc by providing stub symbols (#887)

* Make qdp-kernels build/link on Linux without nvcc by providing stub symbolsy

* fix errors

* fix unsafe error

* fix errors

* fix thr test error

* fix errors

* fix error

* fix stupid error

* try to figure out this stupid error!

Author: rich7420

qdp/qdp-core/src/encoding/amplitude.rs

@@ -16,6 +16,10 @@
 
 //! Amplitude encoding implementation.
 
+// Allow unused_unsafe: qdp_kernels functions are unsafe in CUDA builds but safe stubs in no-CUDA builds.
+// The compiler can't statically determine which path is taken.
+#![allow(unused_unsafe)]
+
 use std::ffi::c_void;
 
 use cudarc::driver::{CudaSlice, DevicePtrMut};

qdp/qdp-core/src/encoding/angle.rs

@@ -16,6 +16,10 @@
 
 //! Angle encoding implementation.
 
+// Allow unused_unsafe: qdp_kernels functions are unsafe in CUDA builds but safe stubs in no-CUDA builds.
+// The compiler can't statically determine which path is taken.
+#![allow(unused_unsafe)]
+
 use std::ffi::c_void;
 
 use qdp_kernels::launch_angle_encode_batch;
@@ -103,22 +107,22 @@ impl ChunkEncoder for AngleEncoder {
             }
         }
 
-        unsafe {
-            crate::profile_scope!("GPU::BatchEncode");
-            let ret = launch_angle_encode_batch(
+        crate::profile_scope!("GPU::BatchEncode");
+        let ret = unsafe {
+            launch_angle_encode_batch(
                 dev_ptr as *const f64,
                 state_ptr_offset,
                 samples_in_chunk,
                 state_len,
                 num_qubits as u32,
                 ctx.stream_compute.stream as *mut c_void,
-            );
-            if ret != 0 {
-                return Err(MahoutError::KernelLaunch(format!(
-                    "Angle encode kernel error: {}",
-                    ret
-                )));
-            }
+            )
+        };
+        if ret != 0 {
+            return Err(MahoutError::KernelLaunch(format!(
+                "Angle encode kernel error: {}",
+                ret
+            )));
         }
         Ok(())
     }

qdp/qdp-core/src/encoding/basis.rs

@@ -16,6 +16,10 @@
 
 //! Basis encoding implementation.
 
+// Allow unused_unsafe: qdp_kernels functions are unsafe in CUDA builds but safe stubs in no-CUDA builds.
+// The compiler can't statically determine which path is taken.
+#![allow(unused_unsafe)]
+
 use std::ffi::c_void;
 
 use cudarc::driver::{CudaSlice, DevicePtr};

qdp/qdp-core/src/gpu/encodings/amplitude.rs

@@ -16,6 +16,10 @@
 
 // Amplitude encoding: state injection with L2 normalization
 
+// Allow unused_unsafe: qdp_kernels functions are unsafe in CUDA builds but safe stubs in no-CUDA builds.
+// The compiler can't statically determine which path is taken.
+#![allow(unused_unsafe)]
+
 use std::sync::Arc;
 
 use super::QuantumEncoder;

qdp/qdp-core/src/gpu/encodings/angle.rs

@@ -16,6 +16,10 @@
 
 // Angle encoding: map per-qubit angles to product state amplitudes.
 
+// Allow unused_unsafe: qdp_kernels functions are unsafe in CUDA builds but safe stubs in no-CUDA builds.
+// The compiler can't statically determine which path is taken.
+#![allow(unused_unsafe)]
+
 use super::QuantumEncoder;
 #[cfg(target_os = "linux")]
 use crate::error::cuda_error_to_string;

qdp/qdp-core/src/gpu/encodings/basis.rs

@@ -16,6 +16,10 @@
 
 // Basis encoding: map integers to computational basis states
 
+// Allow unused_unsafe: qdp_kernels functions are unsafe in CUDA builds but safe stubs in no-CUDA builds.
+// The compiler can't statically determine which path is taken.
+#![allow(unused_unsafe)]
+
 use super::QuantumEncoder;
 #[cfg(target_os = "linux")]
 use crate::error::cuda_error_to_string;

qdp/qdp-core/src/gpu/memory.rs

@@ -13,6 +13,11 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+
+// Allow unused_unsafe: qdp_kernels functions are unsafe in CUDA builds but safe stubs in no-CUDA builds.
+// The compiler can't statically determine which path is taken.
+#![allow(unused_unsafe)]
+
 use crate::error::{MahoutError, Result};
 use cudarc::driver::{CudaDevice, CudaSlice, DevicePtr};
 use qdp_kernels::{CuComplex, CuDoubleComplex};

qdp/qdp-core/src/gpu/pipeline.rs

@@ -19,6 +19,10 @@
 // Provides generic double-buffered execution for large data processing.
 // Separates the "streaming mechanics" from the "kernel logic".
 
+// Allow unused_unsafe: CUDA FFI functions are unsafe in CUDA builds but safe stubs in no-CUDA builds.
+// The compiler can't statically determine which path is taken.
+#![allow(unused_unsafe)]
+
 use crate::error::{MahoutError, Result};
 #[cfg(target_os = "linux")]
 use crate::gpu::buffer_pool::{PinnedBufferHandle, PinnedBufferPool};

qdp/qdp-core/src/lib.rs

@@ -14,6 +14,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+// Allow unused_unsafe: CUDA FFI and kernel functions are unsafe in CUDA builds but safe stubs in no-CUDA builds.
+// The compiler can't statically determine which path is taken.
+#![allow(unused_unsafe)]
+
 pub mod dlpack;
 #[cfg(target_os = "linux")]
 mod encoding;

qdp/qdp-kernels/build.rs

@@ -27,16 +27,27 @@ use std::env;
 use std::process::Command;
 
 fn main() {
+    // Let rustc know about our build-script-defined cfg flags (avoids `unexpected_cfgs` warnings).
+    println!("cargo::rustc-check-cfg=cfg(qdp_no_cuda)");
+
     // Tell Cargo to rerun this script if the kernel sources change
     println!("cargo:rerun-if-changed=src/amplitude.cu");
     println!("cargo:rerun-if-changed=src/basis.cu");
     println!("cargo:rerun-if-changed=src/angle.cu");
+    println!("cargo:rerun-if-env-changed=QDP_NO_CUDA");
     println!("cargo:rerun-if-changed=src/kernel_config.h");
 
     // Check if CUDA is available by looking for nvcc
-    let has_cuda = Command::new("nvcc").arg("--version").output().is_ok();
+    let force_no_cuda = env::var("QDP_NO_CUDA")
+        .map(|v| v == "1" || v.eq_ignore_ascii_case("true") || v.eq_ignore_ascii_case("yes"))
+        .unwrap_or(false);
+
+    let has_cuda = !force_no_cuda && Command::new("nvcc").arg("--version").output().is_ok();
 
     if !has_cuda {
+        // Expose a cfg for conditional compilation of stub symbols on Linux.
+        // This allows qdp-kernels (and dependents) to link on Linux machines without CUDA.
+        println!("cargo:rustc-cfg=qdp_no_cuda");
         println!("cargo:warning=CUDA not found (nvcc not in PATH). Skipping kernel compilation.");
         println!("cargo:warning=This is expected on macOS or non-CUDA environments.");
         println!(