fmt

Author: hsqStephenZhang

src/parser.rs

@@ -30,7 +30,7 @@ use crate::{
     reader::Reader,
     serde::de::invalid_type_number,
     util::{
-        arch::{get_nonspace_bits, prefix_xor},
+        arch::prefix_xor,
         string::*,
         unicode::{codepoint_to_utf8, hex_to_u32_nocheck},
     },
@@ -252,7 +252,7 @@ impl SpaceSkipper {
         // then we use simd to accelerate skipping space
         while let Some(chunk) = reader.peek_n(64) {
             let chunk = unsafe { &*(chunk.as_ptr() as *const [_; 64]) };
-            let bitmap = unsafe { get_nonspace_bits(chunk) };
+            let bitmap = unsafe { crate::util::arch::get_nonspace_bits(chunk) };
             if bitmap != 0 {
                 self.nospace_bits = bitmap;
                 self.nospace_start = reader.index() as isize;
@@ -288,7 +288,7 @@ impl SpaceSkipper {
         // then we use simd to accelerate skipping space
         while let Some(chunk) = reader.peek_n(16) {
             let chunk = unsafe { &*(chunk.as_ptr() as *const [_; 16]) };
-            let bitmap = unsafe { get_nonspace_bits(chunk) };
+            let bitmap = unsafe { crate::util::arch::get_nonspace_bits(chunk) };
             if bitmap != 0 {
                 let cnt = bitmap.trailing_zeros() as usize;
                 let ch = chunk[cnt];

src/util/arch/aarch64.rs

@@ -43,7 +43,6 @@ pub unsafe fn prefix_xor(bitmask: u64) -> u64 {
 // just for minification (or just to identify the structural characters),
 // there is a small untaken optimization opportunity here. We deliberately
 // do not pick it up.
-#[cfg(not(target_feature = "sve2"))]
 #[inline(always)]
 pub unsafe fn get_nonspace_bits(data: &[u8; 64]) -> u64 {
     use std::arch::aarch64::*;
@@ -75,39 +74,3 @@ pub unsafe fn get_nonspace_bits(data: &[u8; 64]) -> u64 {
         chunk_nonspace_bits(vld1q_u8(data.as_ptr().offset(48))),
     )
 }
-
-#[cfg(target_feature = "sve2")]
-#[inline(always)]
-pub unsafe fn get_nonspace_bits(data: &[u8; 16]) -> u64 {
-    let mut index: u64;
-    // 空白符集合: 0x09 (Tab), 0x0A (LF), 0x0D (CR), 0x20 (Space)
-    let tokens: u32 = 0x090a0d20;
-
-    core::arch::asm!(
-        "ptrue  p0.b, vl16",
-        "ld1b   {{z0.b}}, p0/z, [{ptr}]",
-        "mov    z1.s, {t:w}",           // 广播 4 个空白符到 z1
-        
-        // nmatch 寻找不属于 {09, 0a, 0d, 20} 的字符
-        // 结果存入 p1，p1 中 true 的位置表示“非空白符”
-        "nmatch p1.b, p0/z, z0.b, z1.b",
-        
-        // 定位第一个非空白符的位置
-        "brkb   p1.b, p0/z, p1.b",      // 截断，只保留第一个 true 之前的位为 true
-        "cntp   {idx}, p0, p1.b",       // 统计数量，得到第一个非空白符的 index
-
-        ptr = in(reg) data.as_ptr(),
-        t = in(reg) tokens,
-        idx = out(reg) index,
-        out("z0") _, out("z1") _,
-        out("p0") _, out("p1") _,
-    );
-
-    // 如果 index < 16，返回 1 << index，使外部 trailing_zeros() 拿到正确偏移
-    // 如果 index == 16，返回 0，触发外部 skip_space 的“全空白”跳过逻辑
-    if index < 16 {
-        1u64 << index
-    } else {
-        0
-    }
-}

src/util/arch/mod.rs

@@ -2,6 +2,9 @@ cfg_if::cfg_if! {
     if #[cfg(all(target_arch = "x86_64", target_feature = "pclmulqdq", target_feature = "avx2", target_feature = "sse2"))] {
         mod x86_64;
         pub use x86_64::*;
+    } else if #[cfg(all(target_feature="sve2", target_arch="aarch64"))] {
+        mod sve2;
+        pub use sve2::*;
     } else if #[cfg(all(target_feature="neon", target_arch="aarch64"))] {
         mod aarch64;
         pub use aarch64::*;
@@ -13,13 +16,22 @@ cfg_if::cfg_if! {
 
 #[cfg(test)]
 mod test {
-    // use super::*;
+    use super::*;
 
-    // #[test]
-    // fn test_get_non_space_bits() {
-    //     let input = b"\t\r\n xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
-    //     let non_space_bits = unsafe { get_nonspace_bits(input) };
-    //     let expected_bits = 0b1111111111111111111111111111111111111111111111111111111111110000;
-    //     assert_eq!(non_space_bits, expected_bits, "bits is {non_space_bits:b}");
-    // }
+    #[test]
+    fn test_get_non_space_bits() {
+        let input = b"\t\r\n xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
+        cfg_if::cfg_if! {
+            if #[cfg(all(target_feature="sve2", target_arch="aarch64"))] {
+                let non_space_bits = unsafe { get_nonspace_bits(std::mem::transmute(input)) };
+                // sve2 cannot generate the full bitmap(without performance loss)
+                let expected_bits = 0b10000;
+                assert_eq!(non_space_bits, expected_bits, "bits is {non_space_bits:b}");
+            } else {
+                let non_space_bits = unsafe { get_nonspace_bits(input) };
+                let expected_bits = 0b1111111111111111111111111111111111111111111111111111111111110000;
+                assert_eq!(non_space_bits, expected_bits, "bits is {non_space_bits:b}");
+            }
+        }
+    }
 }

src/util/arch/sve2.rs

@@ -0,0 +1,46 @@
+pub unsafe fn prefix_xor(bitmask: u64) -> u64 {
+    let mut bitmask = bitmask;
+    bitmask ^= bitmask << 1;
+    bitmask ^= bitmask << 2;
+    bitmask ^= bitmask << 4;
+    bitmask ^= bitmask << 8;
+    bitmask ^= bitmask << 16;
+    bitmask ^= bitmask << 32;
+    bitmask
+}
+
+/// SVE2 implementation of `get_nonspace_bits`.
+/// But this won't get the full bitmap
+#[inline(always)]
+pub unsafe fn get_nonspace_bits(data: &[u8; 16]) -> u64 {
+    let mut index: u64;
+    // 0x09 (Tab), 0x0A (LF), 0x0D (CR), 0x20 (Space)
+    let tokens: u32 = 0x090a0d20;
+
+    core::arch::asm!(
+        "ptrue  p0.b, vl16",
+        "ld1b   {{z0.b}}, p0/z, [{ptr}]",
+        // broadcast token set
+        "mov    z1.s, {t:w}",
+
+        // nmatch: find token does not match
+        "nmatch p1.b, p0/z, z0.b, z1.b",
+
+        // locate
+        "brkb   p1.b, p0/z, p1.b",
+        // count number of true bits
+        "cntp   {idx}, p0, p1.b",
+
+        ptr = in(reg) data.as_ptr(),
+        t = in(reg) tokens,
+        idx = out(reg) index,
+        out("z0") _, out("z1") _,
+        out("p0") _, out("p1") _,
+    );
+
+    if index < 16 {
+        1u64 << index
+    } else {
+        0
+    }
+}