Ignore kernel tests based on cfg

Author: w1th0utnam3

splashsurf_lib/src/kernel.rs

@@ -235,78 +235,84 @@ impl CubicSplineKernelNeonF32 {
     }
 }
 
-#[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
 #[test]
+#[cfg_attr(
+    not(all(target_arch = "aarch64", target_feature = "neon")),
+    ignore = "Skipped on non-aarch64 targets"
+)]
 fn test_cubic_spline_kernel_neon() {
-    use core::arch::aarch64::*;
+    #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
+    {
+        use core::arch::aarch64::*;
 
-    // Test a few representative compact support radii
-    let hs: [f32; 3] = [0.025, 0.1, 2.0];
-    for &h in hs.iter() {
-        let scalar = CubicSplineKernel::new(h);
-        let neon = CubicSplineKernelNeonF32::new(h);
-
-        // Sample radii from 0 to 2h (beyond support should be 0)
-        let n: usize = 1024;
-        let mut r0: f32 = 0.0;
-        let dr: f32 = (2.0 * h) / (n as f32);
-
-        for _chunk in 0..(n / 4) {
-            // Prepare 4 lanes of radii
-            let rs = [r0, r0 + dr, r0 + 2.0 * dr, r0 + 3.0 * dr];
-            let r_vec = unsafe { vld1q_f32(rs.as_ptr()) };
-
-            // Evaluate NEON and store back to array
-            let w_vec = unsafe { neon.evaluate(r_vec) };
-            let mut w_neon = [0.0f32; 4];
-            unsafe { vst1q_f32(w_neon.as_mut_ptr(), w_vec) };
-
-            // Compare against scalar lane-wise
-            for lane in 0..4 {
-                let r_lane = rs[lane];
-                let w_scalar = scalar.evaluate(r_lane);
-                let diff = (w_neon[lane] - w_scalar).abs();
-
-                // Absolute tolerance with mild relative component to be robust across scales
-                let tol = 5e-6_f32.max(2e-5_f32 * w_scalar.abs());
+        // Test a few representative compact support radii
+        let hs: [f32; 3] = [0.025, 0.1, 2.0];
+        for &h in hs.iter() {
+            let scalar = CubicSplineKernel::new(h);
+            let neon = CubicSplineKernelNeonF32::new(h);
+
+            // Sample radii from 0 to 2h (beyond support should be 0)
+            let n: usize = 1024;
+            let mut r0: f32 = 0.0;
+            let dr: f32 = (2.0 * h) / (n as f32);
+
+            for _chunk in 0..(n / 4) {
+                // Prepare 4 lanes of radii
+                let rs = [r0, r0 + dr, r0 + 2.0 * dr, r0 + 3.0 * dr];
+                let r_vec = unsafe { vld1q_f32(rs.as_ptr()) };
+
+                // Evaluate NEON and store back to array
+                let w_vec = unsafe { neon.evaluate(r_vec) };
+                let mut w_neon = [0.0f32; 4];
+                unsafe { vst1q_f32(w_neon.as_mut_ptr(), w_vec) };
+
+                // Compare against scalar lane-wise
+                for lane in 0..4 {
+                    let r_lane = rs[lane];
+                    let w_scalar = scalar.evaluate(r_lane);
+                    let diff = (w_neon[lane] - w_scalar).abs();
+
+                    // Absolute tolerance with mild relative component to be robust across scales
+                    let tol = 5e-6_f32.max(2e-5_f32 * w_scalar.abs());
+                    assert!(
+                        diff <= tol,
+                        "NEON kernel mismatch (h={}, r={}, lane={}): neon={}, scalar={}, diff={}, tol={}",
+                        h,
+                        r_lane,
+                        lane,
+                        w_neon[lane],
+                        w_scalar,
+                        diff,
+                        tol
+                    );
+                }
+
+                r0 += 4.0 * dr;
+            }
+
+            // Also check a couple of out-of-support points explicitly
+            for &r in &[h * 1.01, h * 1.5, h * 2.0, h * 2.5] {
+                let w_scalar = scalar.evaluate(r);
+                let w_neon = {
+                    let v = unsafe { vld1q_f32([r, r, r, r].as_ptr()) };
+                    let w = unsafe { neon.evaluate(v) };
+                    let mut tmp = [0.0f32; 4];
+                    unsafe { vst1q_f32(tmp.as_mut_ptr(), w) };
+                    tmp[0]
+                };
+                let diff = (w_neon - w_scalar).abs();
+                let tol = 5e-6_f32.max(1e-5_f32 * w_scalar.abs());
                 assert!(
                     diff <= tol,
-                    "NEON kernel mismatch (h={}, r={}, lane={}): neon={}, scalar={}, diff={}, tol={}",
+                    "NEON kernel mismatch outside support (h={}, r={}): neon={}, scalar={}, diff={}, tol={}",
                     h,
-                    r_lane,
-                    lane,
-                    w_neon[lane],
+                    r,
+                    w_neon,
                     w_scalar,
                     diff,
                     tol
                 );
             }
-
-            r0 += 4.0 * dr;
-        }
-
-        // Also check a couple of out-of-support points explicitly
-        for &r in &[h * 1.01, h * 1.5, h * 2.0, h * 2.5] {
-            let w_scalar = scalar.evaluate(r);
-            let w_neon = {
-                let v = unsafe { vld1q_f32([r, r, r, r].as_ptr()) };
-                let w = unsafe { neon.evaluate(v) };
-                let mut tmp = [0.0f32; 4];
-                unsafe { vst1q_f32(tmp.as_mut_ptr(), w) };
-                tmp[0]
-            };
-            let diff = (w_neon - w_scalar).abs();
-            let tol = 5e-6_f32.max(1e-5_f32 * w_scalar.abs());
-            assert!(
-                diff <= tol,
-                "NEON kernel mismatch outside support (h={}, r={}): neon={}, scalar={}, diff={}, tol={}",
-                h,
-                r,
-                w_neon,
-                w_scalar,
-                diff,
-                tol
-            );
         }
     }
 }
@@ -372,94 +378,104 @@ impl CubicSplineKernelAvxF32 {
     }
 }
 
-#[cfg(all(
-    any(target_arch = "x86_64", target_arch = "x86"),
-    target_feature = "avx2",
-    target_feature = "fma"
-))]
 #[test]
+#[cfg_attr(
+    not(all(
+        any(target_arch = "x86_64", target_arch = "x86"),
+        target_feature = "avx2",
+        target_feature = "fma"
+    )),
+    ignore = "Skipped on non-x86 targets"
+)]
 fn test_cubic_spline_kernel_avx() {
-    #[cfg(target_arch = "x86")]
-    use core::arch::x86::*;
-    #[cfg(target_arch = "x86_64")]
-    use core::arch::x86_64::*;
+    #[cfg(all(
+        any(target_arch = "x86_64", target_arch = "x86"),
+        target_feature = "avx2",
+        target_feature = "fma"
+    ))]
+    {
+        #[cfg(target_arch = "x86")]
+        use core::arch::x86::*;
+        #[cfg(target_arch = "x86_64")]
+        use core::arch::x86_64::*;
 
-    // Test a few representative compact support radii
-    let hs: [f32; 3] = [0.025, 0.1, 2.0];
-    for &h in hs.iter() {
-        let scalar = CubicSplineKernel::new(h);
-        let avx = CubicSplineKernelAvxF32::new(h);
-
-        // Sample radii from 0 to 2h (beyond support should be 0)
-        let n: usize = 1024;
-        let mut r0: f32 = 0.0;
-        let dr: f32 = (2.0 * h) / (n as f32);
-
-        for _chunk in 0..(n / 8) {
-            // Prepare 8 lanes of radii
-            let rs = [
-                r0,
-                r0 + dr,
-                r0 + 2.0 * dr,
-                r0 + 3.0 * dr,
-                r0 + 4.0 * dr,
-                r0 + 5.0 * dr,
-                r0 + 6.0 * dr,
-                r0 + 7.0 * dr,
-            ];
-
-            // Evaluate AVX and store back to array
-            let r_vec = unsafe { _mm256_loadu_ps(rs.as_ptr()) };
-            let w_vec = unsafe { avx.evaluate(r_vec) };
-            let mut w_avx = [0.0f32; 8];
-            unsafe { _mm256_storeu_ps(w_avx.as_mut_ptr(), w_vec) };
-
-            // Compare against scalar lane-wise
-            for lane in 0..8 {
-                let r_lane = rs[lane];
-                let w_scalar = scalar.evaluate(r_lane);
-                let diff = (w_avx[lane] - w_scalar).abs();
-
-                // Absolute tolerance with mild relative component to be robust across scales
+        // Test a few representative compact support radii
+        let hs: [f32; 3] = [0.025, 0.1, 2.0];
+        for &h in hs.iter() {
+            let scalar = CubicSplineKernel::new(h);
+            let avx = CubicSplineKernelAvxF32::new(h);
+
+            // Sample radii from 0 to 2h (beyond support should be 0)
+            let n: usize = 1024;
+            let mut r0: f32 = 0.0;
+            let dr: f32 = (2.0 * h) / (n as f32);
+
+            for _chunk in 0..(n / 8) {
+                // Prepare 8 lanes of radii
+                let rs = [
+                    r0,
+                    r0 + dr,
+                    r0 + 2.0 * dr,
+                    r0 + 3.0 * dr,
+                    r0 + 4.0 * dr,
+                    r0 + 5.0 * dr,
+                    r0 + 6.0 * dr,
+                    r0 + 7.0 * dr,
+                ];
+
+                // Evaluate AVX and store back to array
+                let r_vec = unsafe { _mm256_loadu_ps(rs.as_ptr()) };
+                let w_vec = unsafe { avx.evaluate(r_vec) };
+                let mut w_avx = [0.0f32; 8];
+                unsafe { _mm256_storeu_ps(w_avx.as_mut_ptr(), w_vec) };
+
+                // Compare against scalar lane-wise
+                for lane in 0..8 {
+                    let r_lane = rs[lane];
+                    let w_scalar = scalar.evaluate(r_lane);
+                    let diff = (w_avx[lane] - w_scalar).abs();
+
+                    // Absolute tolerance with mild relative component to be robust across scales
+                    let tol = 1e-6_f32.max(1e-5_f32 * w_scalar.abs());
+                    assert!(
+                        diff <= tol,
+                        "AVX kernel mismatch (h={}, r={}, lane={}): avx={}, scalar={}, diff={}, tol={}",
+                        h,
+                        r_lane,
+                        lane,
+                        w_avx[lane],
+                        w_scalar,
+                        diff,
+                        tol
+                    );
+                }
+
+                r0 += 8.0 * dr;
+            }
+
+            // Also check a couple of out-of-support points explicitly
+            for &r in &[h * 1.01, h * 1.5, h * 2.0, h * 2.5] {
+                let w_scalar = scalar.evaluate(r);
+                let w_avx = {
+                    let v = unsafe { _mm256_set1_ps(r) };
+                    let w = unsafe { avx.evaluate(v) };
+                    let mut tmp = [0.0f32; 8];
+                    unsafe { _mm256_storeu_ps(tmp.as_mut_ptr(), w) };
+                    tmp[0]
+                };
+                let diff = (w_avx - w_scalar).abs();
                 let tol = 1e-6_f32.max(1e-5_f32 * w_scalar.abs());
                 assert!(
                     diff <= tol,
-                    "AVX kernel mismatch (h={}, r={}, lane={}): avx={}, scalar={}, diff={}, tol={}",
+                    "AVX kernel mismatch outside support (h={}, r={}): avx={}, scalar={}, diff={}, tol={}",
                     h,
-                    r_lane,
-                    lane,
-                    w_avx[lane],
+                    r,
+                    w_avx,
                     w_scalar,
                     diff,
                     tol
                 );
             }
-
-            r0 += 8.0 * dr;
-        }
-
-        // Also check a couple of out-of-support points explicitly
-        for &r in &[h * 1.01, h * 1.5, h * 2.0, h * 2.5] {
-            let w_scalar = scalar.evaluate(r);
-            let w_avx = {
-                let v = unsafe { _mm256_set1_ps(r) };
-                let w = unsafe { avx.evaluate(v) };
-                let mut tmp = [0.0f32; 8];
-                unsafe { _mm256_storeu_ps(tmp.as_mut_ptr(), w) };
-                tmp[0]
-            };
-            let diff = (w_avx - w_scalar).abs();
-            let tol = 1e-6_f32.max(1e-5_f32 * w_scalar.abs());
-            assert!(
-                diff <= tol,
-                "AVX kernel mismatch outside support (h={}, r={}): avx={}, scalar={}, diff={}, tol={}",
-                h,
-                r,
-                w_avx,
-                w_scalar,
-                diff,
-                tol
-            );
         }
     }
 }