Aarch64 performance fixes

src/implementation/aarch64/neon.rs

@@ -85,7 +85,19 @@ impl SimdU8Value {
     #[inline]
     #[allow(clippy::cast_ptr_alignment)]
     unsafe fn load_from(ptr: *const u8) -> Self {
-        Self::from(vld1q_u8(ptr))
+        // WORKAROUND:
+        // The vld1q_u8 intrinsic is currently broken, it treats it as individual
+        // byte loads so the compiler sometimes decides it is a better to load
+        // individual bytes to "optimize" a subsequent SIMD shuffle
+        //
+        // This code forces a full 128-bit load.
+        let mut dst = core::mem::MaybeUninit::<uint8x16_t>::uninit();
+        core::ptr::copy_nonoverlapping(
+            ptr as *const u8,
+            dst.as_mut_ptr() as *mut u8,
+            core::mem::size_of::<uint8x16_t>(),
+        );
+        Self::from(dst.assume_init())
     }
 
     #[inline]

src/implementation/algorithm.rs

@@ -192,9 +192,20 @@ macro_rules! algorithm_simd {
 
             #[cfg_attr(not(target_arch="aarch64"), target_feature(enable = $feat))]
             #[inline]
+            #[allow(unconditional_panic)] // does not panic because len is checked
+            #[allow(const_err)] // the same, but for Rust 1.38.0
             unsafe fn check_block(&mut self, input: SimdInput) {
-                for i in 0..input.vals.len() {
-                    self.check_bytes(input.vals[i]);
+                // necessary because a for loop is not unrolled on ARM64
+                if input.vals.len() == 2 {
+                    self.check_bytes(input.vals[0]);
+                    self.check_bytes(input.vals[1]);
+                } else if input.vals.len() == 4 {
+                    self.check_bytes(input.vals[0]);
+                    self.check_bytes(input.vals[1]);
+                    self.check_bytes(input.vals[2]);
+                    self.check_bytes(input.vals[3]);
+                } else {
+                    panic!("Unsupported number of chunks");
                 }
             }
         }