centralize cpu feature detection

in the future we can add feature flags for these too (that override runtime detection)

Author: folkertdev

zlib-rs/src/adler32.rs

@@ -7,13 +7,13 @@ mod generic;
 mod neon;
 
 pub fn adler32(start_checksum: u32, data: &[u8]) -> u32 {
-    #[cfg(all(target_arch = "x86_64", feature = "std"))]
-    if std::is_x86_feature_detected!("avx2") {
+    #[cfg(target_arch = "x86_64")]
+    if crate::cpu_features::is_enabled_avx2() {
         return avx2::adler32_avx2(start_checksum, data);
     }
 
-    #[cfg(all(target_arch = "aarch64", feature = "std"))]
-    if std::arch::is_aarch64_feature_detected!("neon") {
+    #[cfg(target_arch = "aarch64")]
+    if crate::cpu_features::is_enabled_neon() {
         return self::neon::adler32_neon(start_checksum, data);
     }
 
@@ -23,8 +23,8 @@ pub fn adler32(start_checksum: u32, data: &[u8]) -> u32 {
 pub fn adler32_fold_copy(start_checksum: u32, dst: &mut [MaybeUninit<u8>], src: &[u8]) -> u32 {
     debug_assert!(dst.len() >= src.len(), "{} < {}", dst.len(), src.len());
 
-    #[cfg(all(target_arch = "x86_64", feature = "std"))]
-    if std::is_x86_feature_detected!("avx2") {
+    #[cfg(target_arch = "x86_64")]
+    if crate::cpu_features::is_enabled_avx2() {
         return avx2::adler32_fold_copy_avx2(start_checksum, dst, src);
     }
 

zlib-rs/src/adler32/avx2.rs

@@ -62,12 +62,12 @@ unsafe fn partial_hsum256(x: __m256i) -> u32 {
 }
 
 pub fn adler32_avx2(adler: u32, src: &[u8]) -> u32 {
-    assert!(std::is_x86_feature_detected!("avx2"));
+    assert!(crate::cpu_features::is_enabled_avx2());
     unsafe { adler32_avx2_help::<false>(adler, &mut [], src) }
 }
 
 pub fn adler32_fold_copy_avx2(adler: u32, dst: &mut [MaybeUninit<u8>], src: &[u8]) -> u32 {
-    assert!(std::is_x86_feature_detected!("avx2"));
+    assert!(crate::cpu_features::is_enabled_avx2());
     unsafe { adler32_avx2_help::<true>(adler, dst, src) }
 }
 

zlib-rs/src/adler32/neon.rs

@@ -19,7 +19,7 @@ const TAPS: [uint16x8x4_t; 2] = unsafe {
 };
 
 pub fn adler32_neon(adler: u32, buf: &[u8]) -> u32 {
-    assert!(std::arch::is_aarch64_feature_detected!("neon"));
+    assert!(crate::cpu_features::is_enabled_neon());
     unsafe { adler32_neon_internal(adler, buf) }
 }
 

zlib-rs/src/cpu_features.rs

@@ -0,0 +1,67 @@
+#![allow(dead_code)]
+#![allow(unreachable_code)]
+
+#[inline(always)]
+pub fn is_enabled_sse() -> bool {
+    #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+    #[cfg(feature = "std")]
+    return std::is_x86_feature_detected!("sse");
+
+    false
+}
+
+#[inline(always)]
+pub fn is_enabled_sse42() -> bool {
+    #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+    #[cfg(feature = "std")]
+    return std::is_x86_feature_detected!("sse4.2");
+
+    false
+}
+
+#[inline(always)]
+pub fn is_enabled_avx2() -> bool {
+    #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+    #[cfg(feature = "std")]
+    return std::is_x86_feature_detected!("avx2");
+
+    false
+}
+
+#[inline(always)]
+pub fn is_enabled_avx512() -> bool {
+    #[cfg(any(target_arch = "x86_64", target_arch = "x86"))]
+    #[cfg(feature = "std")]
+    return std::is_x86_feature_detected!("avx512f");
+
+    false
+}
+
+#[inline(always)]
+pub fn is_enabled_pclmulqdq() -> bool {
+    #[cfg(target_arch = "x86_64")]
+    #[cfg(feature = "std")]
+    return std::is_x86_feature_detected!("pclmulqdq")
+        && std::is_x86_feature_detected!("sse2")
+        && std::is_x86_feature_detected!("sse4.1");
+
+    false
+}
+
+#[inline(always)]
+pub fn is_enabled_neon() -> bool {
+    #[cfg(target_arch = "aarch64")]
+    #[cfg(feature = "std")]
+    return std::arch::is_aarch64_feature_detected!("neon");
+
+    false
+}
+
+#[inline(always)]
+pub fn is_enabled_crc() -> bool {
+    #[cfg(target_arch = "aarch64")]
+    #[cfg(feature = "std")]
+    return std::arch::is_aarch64_feature_detected!("crc");
+
+    false
+}

zlib-rs/src/crc32.rs

@@ -71,25 +71,23 @@ impl Crc32Fold {
         }
     }
 
-    #[cfg(all(target_arch = "x86_64", feature = "std"))]
+    #[cfg_attr(not(target_arch = "x86_64"), allow(unused))]
     pub(crate) fn is_pclmulqdq_enabled() -> bool {
-        std::is_x86_feature_detected!("pclmulqdq")
-            && std::is_x86_feature_detected!("sse2")
-            && std::is_x86_feature_detected!("sse4.1")
+        crate::cpu_features::is_enabled_pclmulqdq()
     }
 
-    #[cfg(all(target_arch = "aarch64", feature = "std"))]
+    #[cfg_attr(not(target_arch = "aarch64"), allow(unused))]
     pub(crate) fn is_crc_enabled() -> bool {
-        std::arch::is_aarch64_feature_detected!("crc")
+        crate::cpu_features::is_enabled_crc()
     }
 
     pub fn fold(&mut self, src: &[u8], _start: u32) {
-        #[cfg(all(target_arch = "x86_64", feature = "std"))]
+        #[cfg(target_arch = "x86_64")]
         if Self::is_pclmulqdq_enabled() {
             return self.fold.fold(src, _start);
         }
 
-        #[cfg(all(target_arch = "aarch64", feature = "std"))]
+        #[cfg(target_arch = "aarch64")]
         if Self::is_crc_enabled() {
             self.value = self::acle::crc32_acle_aarch64(self.value, src);
             return;
@@ -100,7 +98,7 @@ impl Crc32Fold {
     }
 
     pub fn fold_copy(&mut self, dst: &mut [MaybeUninit<u8>], src: &[u8]) {
-        #[cfg(all(target_arch = "x86_64", feature = "std"))]
+        #[cfg(target_arch = "x86_64")]
         if Self::is_pclmulqdq_enabled() {
             return self.fold.fold_copy(dst, src);
         }
@@ -110,7 +108,7 @@ impl Crc32Fold {
     }
 
     pub fn finish(self) -> u32 {
-        #[cfg(all(target_arch = "x86_64", feature = "std"))]
+        #[cfg(target_arch = "x86_64")]
         if Self::is_pclmulqdq_enabled() {
             return unsafe { self.fold.finish() };
         }

zlib-rs/src/deflate/compare256.rs

@@ -10,13 +10,13 @@ pub fn compare256_slice(src0: &[u8], src1: &[u8]) -> usize {
 }
 
 fn compare256(src0: &[u8; 256], src1: &[u8; 256]) -> usize {
-    #[cfg(all(target_arch = "x86_64", feature = "std"))]
-    if std::is_x86_feature_detected!("avx2") {
+    #[cfg(target_arch = "x86_64")]
+    if crate::cpu_features::is_enabled_avx2() {
         return unsafe { avx2::compare256(src0, src1) };
     }
 
-    #[cfg(all(target_arch = "aarch64", feature = "std"))]
-    if std::arch::is_aarch64_feature_detected!("neon") {
+    #[cfg(target_arch = "aarch64")]
+    if crate::cpu_features::is_enabled_neon() {
         return unsafe { neon::compare256(src0, src1) };
     }
 
@@ -150,7 +150,7 @@ mod neon {
 
     #[test]
     fn test_compare256() {
-        if std::arch::is_aarch64_feature_detected!("neon") {
+        if crate::cpu_features::is_enabled_neon() {
             let str1 = [b'a'; super::MAX_COMPARE_SIZE];
             let mut str2 = [b'a'; super::MAX_COMPARE_SIZE];
 
@@ -204,7 +204,7 @@ mod avx2 {
 
     #[test]
     fn test_compare256() {
-        if std::arch::is_x86_feature_detected!("avx2") {
+        if crate::cpu_features::is_enabled_avx2() {
             let str1 = [b'a'; super::MAX_COMPARE_SIZE];
             let mut str2 = [b'a'; super::MAX_COMPARE_SIZE];
 

zlib-rs/src/deflate/hash_calc.rs

@@ -135,12 +135,12 @@ pub struct Crc32HashCalc;
 
 impl Crc32HashCalc {
     fn is_supported() -> bool {
-        #[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), feature = "std"))]
-        return std::arch::is_x86_feature_detected!("sse4.2");
+        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+        return crate::cpu_features::is_enabled_sse42();
 
         // NOTE: more recent versions of zlib-ng no longer use the crc instructions on aarch64
-        #[cfg(all(target_arch = "aarch64", feature = "std"))]
-        return std::arch::is_aarch64_feature_detected!("crc");
+        #[cfg(target_arch = "aarch64")]
+        return crate::cpu_features::is_enabled_crc();
 
         #[allow(unreachable_code)]
         false

zlib-rs/src/deflate/slide_hash.rs

@@ -6,13 +6,13 @@ pub fn slide_hash(state: &mut crate::deflate::State) {
 }
 
 fn slide_hash_chain(table: &mut [u16], wsize: u16) {
-    #[cfg(all(target_arch = "x86_64", feature = "std"))]
-    if std::is_x86_feature_detected!("avx2") {
+    #[cfg(target_arch = "x86_64")]
+    if crate::cpu_features::is_enabled_avx2() {
         return avx2::slide_hash_chain(table, wsize);
     }
 
-    #[cfg(all(target_arch = "aarch64", feature = "std"))]
-    if std::arch::is_aarch64_feature_detected!("neon") {
+    #[cfg(target_arch = "aarch64")]
+    if crate::cpu_features::is_enabled_neon() {
         return neon::slide_hash_chain(table, wsize);
     }
 
@@ -34,7 +34,7 @@ mod neon {
     };
 
     pub fn slide_hash_chain(table: &mut [u16], wsize: u16) {
-        assert!(std::arch::is_aarch64_feature_detected!("neon"));
+        assert!(crate::cpu_features::is_enabled_neon());
         unsafe { slide_hash_chain_internal(table, wsize) }
     }
 
@@ -71,7 +71,7 @@ mod avx2 {
     };
 
     pub fn slide_hash_chain(table: &mut [u16], wsize: u16) {
-        assert!(std::is_x86_feature_detected!("avx2"));
+        assert!(crate::cpu_features::is_enabled_avx2());
         unsafe { slide_hash_chain_internal(table, wsize) }
     }
 
@@ -123,7 +123,7 @@ mod tests {
     #[test]
     #[cfg(target_arch = "x86_64")]
     fn test_slide_hash_avx2() {
-        if std::arch::is_x86_feature_detected!("avx2") {
+        if crate::cpu_features::is_enabled_avx2() {
             let mut input = INPUT;
 
             avx2::slide_hash_chain(&mut input, WSIZE);
@@ -135,7 +135,7 @@ mod tests {
     #[test]
     #[cfg(target_arch = "aarch64")]
     fn test_slide_hash_neon() {
-        if std::arch::is_aarch64_feature_detected!("neon") {
+        if crate::cpu_features::is_enabled_neon() {
             let mut input = INPUT;
 
             neon::slide_hash_chain(&mut input, WSIZE);

zlib-rs/src/deflate/window.rs

@@ -132,15 +132,10 @@ impl<'a> Window<'a> {
 
     // padding required so that SIMD operations going out-of-bounds are not a problem
     pub fn padding() -> usize {
-        #[cfg(feature = "std")]
-        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-        if std::is_x86_feature_detected!("pclmulqdq")
-            && std::is_x86_feature_detected!("sse2")
-            && std::is_x86_feature_detected!("sse4.1")
-        {
-            return 8;
+        if crate::cpu_features::is_enabled_pclmulqdq() {
+            8
+        } else {
+            0
         }
-
-        0
     }
 }

zlib-rs/src/lib.rs

@@ -7,6 +7,7 @@ extern crate alloc;
 mod adler32;
 pub mod allocate;
 pub mod c_api;
+mod cpu_features;
 pub mod crc32;
 pub mod deflate;
 pub mod inflate;

zlib-rs/src/read_buf.rs

@@ -199,18 +199,18 @@ impl<'a> ReadBuf<'a> {
 
     #[inline(always)]
     pub fn copy_match(&mut self, offset_from_end: usize, length: usize) {
-        #[cfg(all(target_arch = "x86_64", feature = "std"))]
-        if std::is_x86_feature_detected!("avx512f") {
+        #[cfg(target_arch = "x86_64")]
+        if crate::cpu_features::is_enabled_avx512() {
             return self.copy_match_help::<core::arch::x86_64::__m512i>(offset_from_end, length);
         }
 
-        #[cfg(all(target_arch = "x86_64", feature = "std"))]
-        if std::is_x86_feature_detected!("avx2") {
+        #[cfg(target_arch = "x86_64")]
+        if crate::cpu_features::is_enabled_avx2() {
             return self.copy_match_help::<core::arch::x86_64::__m256i>(offset_from_end, length);
         }
 
-        #[cfg(all(target_arch = "x86_64", feature = "std"))]
-        if std::is_x86_feature_detected!("sse") {
+        #[cfg(target_arch = "x86_64")]
+        if crate::cpu_features::is_enabled_sse() {
             return self.copy_match_help::<core::arch::x86_64::__m128i>(offset_from_end, length);
         }