[QDP] Complete Tensor Core IQP path remediation

.github/workflows/python-testing.yml

@@ -50,7 +50,17 @@ jobs:
       - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6
 
       - name: Install Rust toolchain
-        uses: dtolnay/rust-toolchain@29eef336d9b2848a0b548edc03f92a220660cdb8 # stable
+        shell: bash
+        run: |
+          if ! command -v rustup >/dev/null 2>&1; then
+            curl https://sh.rustup.rs -sSf | sh -s -- -y --profile minimal --default-toolchain stable
+          else
+            rustup toolchain install stable --profile minimal
+            rustup default stable
+          fi
+          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
+          "$HOME/.cargo/bin/rustc" --version
+          "$HOME/.cargo/bin/cargo" --version
 
       - name: Cargo check (no-CUDA stubs)
         working-directory: qdp
@@ -62,7 +72,7 @@ jobs:
       # GPU fidelity cases self-skip when the probe finds no functional GPU
       # (stub build: kernel launch returns Err; no driver: cudarc panics and
       # catch_unwind treats it as skip). Reader-level assertions still run.
-      # Scoped to these two binaries — other gpu_*.rs tests lack probe-skip.
+      # Scoped to these two binaries -- other gpu_*.rs tests lack probe-skip.
       - name: Cargo test (f32 Parquet CPU smoke)
         working-directory: qdp
         env:

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

@@ -64,6 +64,114 @@ impl IqpEncoder {
             num_qubits
         }
     }
+
+    /// Encode multiple IQP samples using Matrix-Free Implicit Hadamard Tensor Core engine
+    #[cfg(target_os = "linux")]
+    pub fn encode_batch_tc(
+        &self,
+        device: &Arc<CudaDevice>,
+        batch_data: &[f64],
+        num_samples: usize,
+        sample_size: usize,
+        num_qubits: usize,
+    ) -> Result<GpuStateVector> {
+        validate_qubit_count(num_qubits)?;
+        let expected_len = self.expected_data_len(num_qubits);
+
+        if sample_size != expected_len {
+            return Err(MahoutError::InvalidInput(format!(
+                "Batch sample size {} does not match required parameters {}",
+                sample_size, expected_len
+            )));
+        }
+
+        if batch_data.len() != num_samples * sample_size {
+            return Err(MahoutError::InvalidInput(format!(
+                "Batch data length {} does not match num_samples {} * sample_size {}",
+                batch_data.len(),
+                num_samples,
+                sample_size
+            )));
+        }
+
+        for (i, &val) in batch_data.iter().enumerate() {
+            if !val.is_finite() {
+                let sample_idx = i / sample_size;
+                let param_idx = i % sample_size;
+                return Err(MahoutError::InvalidInput(format!(
+                    "Sample {} parameter {} must be finite, got {}",
+                    sample_idx, param_idx, val
+                )));
+            }
+        }
+
+        let state_len = 1 << num_qubits;
+
+        let batch_state_vector = {
+            crate::profile_scope!("GPU::AllocBatchTC");
+            GpuStateVector::new_batch(device, num_samples, num_qubits, Precision::Float64)?
+        };
+
+        let input_bytes = std::mem::size_of_val(batch_data);
+        let data_gpu = {
+            crate::profile_scope!("GPU::H2D_BatchIqpDataTC");
+            device.htod_sync_copy(batch_data).map_err(|e| {
+                map_allocation_error(input_bytes, "IQP TC batch upload", Some(num_qubits), e)
+            })?
+        };
+
+        let state_ptr = batch_state_vector.ptr_f64().ok_or_else(|| {
+            MahoutError::InvalidInput(
+                "Batch state vector precision mismatch (expected float64 buffer)".to_string(),
+            )
+        })?;
+
+        {
+            crate::profile_scope!("GPU::BatchKernelLaunchTC");
+            let ret = unsafe {
+                qdp_kernels::launch_iqp_encode_tc(
+                    *data_gpu.device_ptr() as *const f64,
+                    state_ptr as *mut c_void,
+                    num_samples,
+                    state_len,
+                    num_qubits as u32,
+                    if self.enable_zz { 1 } else { 0 },
+                    (*device.cu_stream()) as *mut c_void,
+                )
+            };
+
+            if ret != 0 {
+                return Err(MahoutError::KernelLaunch(format!(
+                    "Batch IQP TC encoding kernel failed: {} ({})",
+                    ret,
+                    cuda_error_to_string(ret)
+                )));
+            }
+        }
+
+        {
+            crate::profile_scope!("GPU::SynchronizeTC");
+            device
+                .synchronize()
+                .map_err(|e| MahoutError::Cuda(format!("Sync failed: {:?}", e)))?;
+        }
+
+        Ok(batch_state_vector)
+    }
+
+    #[cfg(not(target_os = "linux"))]
+    pub fn encode_batch_tc(
+        &self,
+        _device: &Arc<CudaDevice>,
+        _batch_data: &[f64],
+        _num_samples: usize,
+        _sample_size: usize,
+        _num_qubits: usize,
+    ) -> Result<GpuStateVector> {
+        Err(MahoutError::Cuda(
+            "CUDA unavailable (non-Linux stub)".to_string(),
+        ))
+    }
 }
 
 impl QuantumEncoder for IqpEncoder {

qdp/qdp-core/src/lib.rs

@@ -213,6 +213,40 @@ impl QdpEngine {
         self.encode_batch_for_pipeline(batch_data, num_samples, sample_size, num_qubits, encoding)
     }
 
+    /// Encode a batch of IQP samples via the Tensor Core / Kronecker FWT path.
+    #[cfg(target_os = "linux")]
+    pub fn encode_batch_tc(
+        &self,
+        batch_data: &[f64],
+        num_samples: usize,
+        sample_size: usize,
+        num_qubits: usize,
+        encoding_method: &str,
+    ) -> Result<*mut DLManagedTensor> {
+        crate::profile_scope!("Mahout::EncodeBatchTC");
+
+        let encoding = Encoding::from_str_ci(encoding_method)?;
+        let encoder = match encoding {
+            Encoding::Iqp => gpu::encodings::IqpEncoder::full(),
+            Encoding::IqpZ => gpu::encodings::IqpEncoder::z_only(),
+            _ => {
+                return Err(MahoutError::InvalidInput(format!(
+                    "encode_batch_tc supports iqp and iqp-z only, got {}",
+                    encoding_method
+                )));
+            }
+        };
+        let state_vector = encoder.encode_batch_tc(
+            &self.device,
+            batch_data,
+            num_samples,
+            sample_size,
+            num_qubits,
+        )?;
+
+        Ok(state_vector.to_dlpack())
+    }
+
     /// Same as [`encode_batch`](Self::encode_batch) with a resolved [`Encoding`] (no string parse).
     pub(crate) fn encode_batch_for_pipeline(
         &self,

qdp/qdp-kernels/build.rs

@@ -26,9 +26,9 @@
 use std::env;
 use std::process::Command;
 
-const DEFAULT_CUBIN_ARCHES: &[&str] = &["75", "80", "86", "89", "90", "100", "120"];
-const DEFAULT_PTX_CANDIDATES: &[&str] = &["120", "100", "90", "89", "86", "80", "75"];
-const LEGACY_FALLBACK_ARCHES: &[&str] = &["75", "80", "86"];
+const DEFAULT_CUBIN_ARCHES: &[&str] = &["80", "86", "89", "90", "100", "120"];
+const DEFAULT_PTX_CANDIDATES: &[&str] = &["120", "100", "90", "89", "86", "80"];
+const LEGACY_FALLBACK_ARCHES: &[&str] = &["80", "86"];
 
 fn add_sm_target(build: &mut cc::Build, arch: &str) {
     build.flag("-gencode");
@@ -164,6 +164,7 @@ fn main() {
     println!("cargo:rerun-if-changed=src/angle.cu");
     println!("cargo:rerun-if-changed=src/validation.cu");
     println!("cargo:rerun-if-changed=src/iqp.cu");
+    println!("cargo:rerun-if-changed=src/iqp_tc.cu");
     println!("cargo:rerun-if-changed=src/phase.cu");
     println!("cargo:rerun-if-env-changed=QDP_NO_CUDA");
     println!("cargo:rerun-if-env-changed=QDP_CUDA_ARCH_LIST");
@@ -232,6 +233,8 @@ fn main() {
         .file("src/angle.cu")
         .file("src/validation.cu")
         .file("src/iqp.cu")
+        .file("src/iqp_tc.cu")
+        .file("src/ImplicitHadamardOzaki.cu")
         .file("src/phase.cu")
         .compile("kernels");
 }