Rework SIMD level handling in tests

Author: valadaptive

fearless_simd_dev_macros/src/lib.rs

@@ -52,18 +52,20 @@ pub fn simd_test(_: TokenStream, item: TokenStream) -> TokenStream {
     // proc macros are evaluated.
 
     // There is currently no way to conditionally ignore a test at runtime (see
-    // https://internals.rust-lang.org/t/pre-rfc-skippable-tests/14611). Instead, we have to assert that these CPU
-    // features are always detected and fail the test if they aren't.
+    // https://internals.rust-lang.org/t/pre-rfc-skippable-tests/14611). Instead, we'll just pass the tests if the
+    // target features aren't supported. This is not ideal, since it may mislead you into thinking tests have passed
+    // when they haven't even been run, but some CI runners don't support all target features and we don't want failures
+    // as a result of that.
 
     let neon_snippet = quote! {
         #[cfg(target_arch = "aarch64")]
         #[test]
         #ignore_neon
         fn #neon_name() {
-            assert!(std::arch::is_aarch64_feature_detected!("neon"));
-
-            let neon = unsafe { fearless_simd::aarch64::Neon::new_unchecked() };
-            #input_fn_name(neon);
+            if std::arch::is_aarch64_feature_detected!("neon") {
+                let neon = unsafe { fearless_simd::aarch64::Neon::new_unchecked() };
+                #input_fn_name(neon);
+            }
         }
     };
 
@@ -72,10 +74,10 @@ pub fn simd_test(_: TokenStream, item: TokenStream) -> TokenStream {
         #[test]
         #ignore_sse4
         fn #sse4_name() {
-            assert!(std::arch::is_x86_feature_detected!("sse4.2"));
-
-            let sse4 = unsafe { fearless_simd::x86::Sse4_2::new_unchecked() };
-            #input_fn_name(sse4);
+            if std::arch::is_x86_feature_detected!("sse4.2") {
+                let sse4 = unsafe { fearless_simd::x86::Sse4_2::new_unchecked() };
+                #input_fn_name(sse4);
+            }
         }
     };
 
@@ -84,13 +86,12 @@ pub fn simd_test(_: TokenStream, item: TokenStream) -> TokenStream {
         #[test]
         #ignore_avx2
         fn #avx2_name() {
-            assert!(
-                std::arch::is_x86_feature_detected!("avx2")
+            if std::arch::is_x86_feature_detected!("avx2")
                 && std::arch::is_x86_feature_detected!("fma")
-            );
-
-            let avx2 = unsafe { fearless_simd::x86::Avx2::new_unchecked() };
-            #input_fn_name(avx2);
+            {
+                let avx2 = unsafe { fearless_simd::x86::Avx2::new_unchecked() };
+                #input_fn_name(avx2);
+            }
         }
     };
 

fearless_simd_tests/tests/mod.rs

@@ -37,3 +37,30 @@ fn saturate_float_to_int<S: Simd>(simd: S) {
 fn generic_cast<S: Simd>(x: S::f32s) -> S::u32s {
     x.to_int()
 }
+
+#[test]
+fn supports_highest_level() {
+    // When running tests locally, ensure that every SIMD level to be tested is actually supported. The tests themselves
+    // will return early and pass if run with an unsupported SIMD level.
+    //
+    // We skip this on CI because some runners may not support all SIMD levels--in particular, the macOS x86_64 runner
+    // doesn't support AVX2.
+    if std::env::var_os("CI").is_none() {
+        let level = Level::new();
+
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+        assert!(
+            level.as_avx2().is_some(),
+            "This machine supports AVX2 and below"
+        );
+
+        #[cfg(target_arch = "aarch64")]
+        assert!(level.as_neon().is_some(), "This machine supports NEON");
+
+        #[cfg(all(target_arch = "wasm32", target_feature = "simd128"))]
+        assert!(
+            level.as_wasm_simd128().is_some(),
+            "This environment supports WASM SIMD128"
+        );
+    }
+}