Build all tests for better cross-compilation (#126)

This was discussed a bit in #122. We were previously omitting
architecture-specific tests based on the *host* architecture, which is
incorrect and prevents cross-compiling tests to run under something like
qemu.

We can't access `CARGO_CFG_TARGET_ARCH` at the time that proc macros are
evaluated, so we just have to build every architecture-specific test and
use `#[cfg]` to disable ones that aren't applicable to the current
architecture.

Even more annoyingly, there's no way to conditionally ignore a test at
runtime. This means that if the CPU we're running the tests on doesn't
support a target feature, we have to either pass or fail that test. I've
chosen to fail, to prevent faulty code from appearing to pass tests.

I've also updated the architecture-specific `exclude` functions to add
`#[ignore]` attributes rather than omitting the tests entirely. This
makes it more clear that the tests exist, but are not being run because
they don't yet pass.

Author: valadaptive

fearless_simd_dev_macros/src/lib.rs

@@ -23,91 +23,86 @@ pub fn simd_test(_: TokenStream, item: TokenStream) -> TokenStream {
     let avx2_name = get_ident("avx2");
     let wasm_name = get_ident("wasm");
 
-    let include_fallback = !exclude_fallback(&input_fn_name.to_string());
-    #[cfg(target_arch = "aarch64")]
-    let include_neon = std::arch::is_aarch64_feature_detected!("neon")
-        && !exclude_neon(&input_fn_name.to_string());
-    #[cfg(not(target_arch = "aarch64"))]
-    let include_neon = false;
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    let include_sse4 =
-        std::arch::is_x86_feature_detected!("sse4.2") && !exclude_sse4(&input_fn_name.to_string());
-    #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
-    let include_sse4 = false;
-    #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-    let include_avx2 = std::arch::is_x86_feature_detected!("avx2")
-        && std::arch::is_x86_feature_detected!("fma")
-        && !exclude_avx2(&input_fn_name.to_string());
-    #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
-    let include_avx2 = false;
-    // Note that we cannot feature-gate this with `target_arch`. If we run
-    // `cargo test --target wasm32-wasip1`, then the `target_arch` will still be set to
-    // the operating system you are running on. Because of this, we instead add the `target_arch`
-    // feature gate to the actual test.
-    let include_wasm = !exclude_wasm(&input_fn_name.to_string());
-
-    let fallback_snippet = if include_fallback {
-        quote! {
-            #[test]
-            fn #fallback_name() {
-                let fallback = fearless_simd::Fallback::new();
-                #input_fn_name(fallback);
-            }
+    let ignore_attr = |f: fn(&str) -> bool| {
+        let should_ignore = f(&input_fn_name.to_string());
+        if should_ignore {
+            quote! { #[ignore] }
+        } else {
+            quote! {}
         }
-    } else {
-        quote! {}
     };
 
-    let neon_snippet = if include_neon {
-        quote! {
-            #[cfg(target_arch = "aarch64")]
-            #[test]
-            fn #neon_name() {
+    let ignore_fallback = ignore_attr(exclude_fallback);
+    let ignore_neon = ignore_attr(exclude_neon);
+    let ignore_sse4 = ignore_attr(exclude_sse4);
+    let ignore_avx2 = ignore_attr(exclude_avx2);
+    let ignore_wasm = ignore_attr(exclude_wasm);
+
+    let fallback_snippet = quote! {
+        #[test]
+        #ignore_fallback
+        fn #fallback_name() {
+            let fallback = fearless_simd::Fallback::new();
+            #input_fn_name(fallback);
+        }
+    };
+
+    // All of the architecture-specific tests need to be included every time, and #[cfg]'d out depending on the target
+    // architecture. We can't use `CARGO_CFG_TARGET_ARCH` to conditionally omit them because it's not available when
+    // 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'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() {
+            if std::arch::is_aarch64_feature_detected!("neon") {
                 let neon = unsafe { fearless_simd::aarch64::Neon::new_unchecked() };
                 #input_fn_name(neon);
             }
         }
-    } else {
-        quote! {}
     };
 
-    let sse4_snippet = if include_sse4 {
-        quote! {
-            #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-            #[test]
-            fn #sse4_name() {
+    let sse4_snippet = quote! {
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+        #[test]
+        #ignore_sse4
+        fn #sse4_name() {
+            if std::arch::is_x86_feature_detected!("sse4.2") {
                 let sse4 = unsafe { fearless_simd::x86::Sse4_2::new_unchecked() };
                 #input_fn_name(sse4);
             }
         }
-    } else {
-        quote! {}
     };
 
-    let avx2_snippet = if include_avx2 {
-        quote! {
-            #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-            #[test]
-            fn #avx2_name() {
+    let avx2_snippet = quote! {
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+        #[test]
+        #ignore_avx2
+        fn #avx2_name() {
+            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);
             }
         }
-    } else {
-        quote! {}
     };
 
-    let wasm_snippet = if include_wasm {
-        quote! {
-            #[cfg(all(target_arch = "wasm32", target_feature = "simd128"))]
-            #[test]
-            fn #wasm_name() {
-                let wasm = unsafe { fearless_simd::wasm32::WasmSimd128::new_unchecked() };
-                #input_fn_name(wasm);
-            }
+    let wasm_snippet = quote! {
+        #[cfg(all(target_arch = "wasm32", target_feature = "simd128"))]
+        #[test]
+        #ignore_wasm
+        fn #wasm_name() {
+            let wasm = unsafe { fearless_simd::wasm32::WasmSimd128::new_unchecked() };
+            #input_fn_name(wasm);
         }
-    } else {
-        quote! {}
     };
 
     quote! {
@@ -125,8 +120,6 @@ pub fn simd_test(_: TokenStream, item: TokenStream) -> TokenStream {
 // You can update below functions if you want to exclude certain tests from different architectures
 // (for example because they haven't been implemented yet).
 
-#[allow(clippy::allow_attributes, reason = "Lints only apply in some cfgs.")]
-#[allow(dead_code, reason = "Used only on aarch64, but always type-checked.")]
 fn exclude_neon(_test_name: &str) -> bool {
     false
 }
@@ -135,8 +128,6 @@ fn exclude_fallback(_test_name: &str) -> bool {
     false
 }
 
-#[allow(clippy::allow_attributes, reason = "Lints only apply in some cfgs.")]
-#[allow(dead_code, reason = "Used only on x86(-64), but always type-checked.")]
 fn exclude_sse4(test_name: &str) -> bool {
     matches!(
         test_name,
@@ -145,8 +136,6 @@ fn exclude_sse4(test_name: &str) -> bool {
     ) || test_name.contains("precise")
 }
 
-#[allow(clippy::allow_attributes, reason = "Lints only apply in some cfgs.")]
-#[allow(dead_code, reason = "Used only on x86(-64), but always type-checked.")]
 fn exclude_avx2(test_name: &str) -> bool {
     matches!(
         test_name,
@@ -155,8 +144,6 @@ fn exclude_avx2(test_name: &str) -> bool {
     ) || test_name.contains("precise")
 }
 
-#[allow(clippy::allow_attributes, reason = "Lints only apply in some cfgs.")]
-#[allow(dead_code, reason = "Used only on wasm32, but always type-checked.")]
 fn exclude_wasm(test_name: &str) -> bool {
     matches!(
         test_name,

fearless_simd_tests/tests/mod.rs

@@ -37,3 +37,47 @@ fn saturate_float_to_int<S: Simd>(simd: S) {
 fn generic_cast<S: Simd>(x: S::f32s) -> S::u32s {
     x.to_int()
 }
+
+#[allow(clippy::allow_attributes, reason = "Only needed in some cfgs.")]
+#[allow(
+    unused_variables,
+    reason = "The constructed `Level` is only used in some cfgs."
+)]
+#[allow(
+    dead_code,
+    reason = "The `UNSUPPORTED_LEVEL_MESSAGE` is only used in some cfgs."
+)]
+#[test]
+fn supports_highest_level() {
+    const UNSUPPORTED_LEVEL_MESSAGE: &str = "This means that some of the other tests in this run may be false positives, that is, they have been marked as succeeding even though they would actually fail if they could run.\n\
+        When these tests are run on CI, any false positives should be caught.\n\
+        However, please open a thread in the #simd channel on the Linebender Zulip if you see this message.\n\
+        That would allow us to know whether it's worth us setting up the tests to run on an emulated system (such as using QEMU).";
+
+    let level = Level::new();
+
+    // 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() {
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+        assert!(
+            level.as_avx2().is_some(),
+            "This machine does not support every `Level` supported by Fearless SIMD (currently AVX2 and below).\n{UNSUPPORTED_LEVEL_MESSAGE}",
+        );
+
+        #[cfg(target_arch = "aarch64")]
+        assert!(
+            level.as_neon().is_some(),
+            "This machine does not support every `Level` supported by Fearless SIMD (currently NEON and below).\n{UNSUPPORTED_LEVEL_MESSAGE}",
+        );
+    }
+
+    #[cfg(all(target_arch = "wasm32", target_feature = "simd128"))]
+    assert!(
+        level.as_wasm_simd128().is_some(),
+        "This environment does not support WASM SIMD128. This should never happen, since it should always be supported if the `simd128` feature is enabled."
+    );
+}