A little optimization

Author: Brooooooklyn

Cargo.toml

@@ -24,6 +24,7 @@ serde_json = "1"
 
 [profile.bench]
 lto = true
+codegen-units = 1
 
 [profile.instruments]
 inherits = "release"

src/aarch64.rs

@@ -1,5 +1,12 @@
 use std::arch::aarch64::{
-    uint8x16_t, vaddq_u8, vaddvq_u8, vceqq_u8, vdupq_n_u8, vld1q_u8, vld1q_u8_x4, vqtbl4q_u8,
+    uint8x16_t, // lane type
+    vceqq_u8,
+    vdupq_n_u8, // comparisons / splat
+    vld1q_u8,
+    vld1q_u8_x4, // loads
+    vmaxvq_u8,   // horizontal-max reduction
+    vorrq_u8,    // bit-wise OR
+    vqtbl4q_u8,  // table-lookup
 };
 use std::mem::transmute;
 
@@ -17,36 +24,35 @@ pub fn encode_str<S: AsRef<str>>(input: S) -> String {
     // Safety: SIMD instructions
     unsafe {
         let mut start = 0;
+        let table_low = vld1q_u8_x4(ESCAPE[0..64].as_ptr());
+        let table_high = vdupq_n_u8(b'\\');
         while start + CHUNK_SIZE < len {
-            let next_chunk = start + CHUNK_SIZE;
-            let current_chunk_slice = &bytes[start..next_chunk];
-            let table_low = vld1q_u8_x4(ESCAPE[0..64].as_ptr());
-            let table_high = vdupq_n_u8(b'\\');
-            let chunk = vld1q_u8(current_chunk_slice.as_ptr());
+            let current = &bytes[start..start + CHUNK_SIZE];
+
+            let chunk = vld1q_u8(current.as_ptr());
             let low_mask = vqtbl4q_u8(table_low, chunk);
             let high_mask = vceqq_u8(table_high, chunk);
-            if vaddvq_u8(low_mask) == 0 && vaddvq_u8(high_mask) == 0 {
-                writer.extend_from_slice(current_chunk_slice);
-                start = next_chunk;
+            if vmaxvq_u8(low_mask) == 0 && vmaxvq_u8(high_mask) == 0 {
+                writer.extend_from_slice(current);
+                start += CHUNK_SIZE;
                 continue;
             }
 
             // Vector add the masks to get a single mask
-            let escape_table_mask = vaddq_u8(low_mask, high_mask);
-            let escape_table_mask_slice = transmute::<uint8x16_t, [u8; 16]>(escape_table_mask);
+            let escape_mask = vorrq_u8(low_mask, high_mask);
+            let escape_table_mask_slice = transmute::<uint8x16_t, [u8; 16]>(escape_mask);
             for (index, value) in escape_table_mask_slice.into_iter().enumerate() {
                 if value == 0 {
                     writer.push(bytes[start + index]);
                 } else if value == 255 {
                     // value is in the high table mask, which means it's `\`
                     writer.extend_from_slice(REVERSE_SOLIDUS);
                 } else {
-                    let char_escape =
-                        CharEscape::from_escape_table(value, current_chunk_slice[index]);
+                    let char_escape = CharEscape::from_escape_table(value, current[index]);
                     write_char_escape(writer, char_escape);
                 }
             }
-            start = next_chunk;
+            start += CHUNK_SIZE;
         }
 
         if start < len {