tmp

Author: hsqStephenZhang

.cargo/config.toml

@@ -10,4 +10,9 @@ rustflags    = ["-g", "-C", "target-cpu=native"]
 rustflags = ["-C", "target-feature=+simd128"]
 
 [target.wasm32-wasi]
-rustflags = ["-C", "target-feature=+simd128"]
+rustflags = ["-C", "target-feature=+simd128"]
+
+[target.aarch64-unknown-linux-gnu]
+runner   = "qemu-aarch64 -L /usr/aarch64-linux-gnu -cpu max,sve=on"
+rustflags = ["-C", "target-feature=+sve2"]
+linker   = "aarch64-linux-gnu-gcc"

sonic-simd/src/bits.rs

@@ -100,3 +100,150 @@ impl BitMask for NeonBits {
         Self(self.0 & u64::MAX >> (n * 4))
     }
 }
+
+#[cfg(target_feature = "sve2")]
+#[derive(Debug, Clone, Copy)]
+pub struct SveBits(usize);
+
+#[cfg(target_feature = "sve2")]
+impl SveBits {
+    #[inline(always)]
+    pub fn new(u: usize) -> Self {
+        Self(u)
+    }
+}
+
+#[cfg(target_feature = "sve2")]
+impl BitMask for SveBits {
+    const LEN: usize = 16;
+
+    #[inline(always)]
+    fn first_offset(&self) -> usize {
+        self.0
+    }
+
+    #[inline(always)]
+    fn before(&self, rhs: &Self) -> bool {
+        self.0 < rhs.0
+    }
+
+    #[inline(always)]
+    fn all_zero(&self) -> bool {
+        self.0 == 16
+    }
+
+    #[inline(always)]
+    fn as_little_endian(&self) -> Self {
+        *self
+    }
+
+    #[inline(always)]
+    fn clear_high_bits(&self, n: usize) -> Self {
+        let nb = 16 - n;
+
+        if self.0 >= nb {
+            Self(16)
+        } else {
+            *self
+        }
+    }
+}
+
+#[cfg(test)]
+#[cfg(target_feature = "sve2")]
+#[cfg(target_arch = "aarch64")]
+mod tests {
+    use super::*;
+
+    #[derive(Debug)]
+    struct SVEStringBlock {
+        bs_bits: SveBits,
+        quote_bits: SveBits,
+        unescaped_bits: SveBits,
+    }
+
+    impl SVEStringBlock {
+        #[inline(always)]
+        pub fn new_sve(ptr: *const u8) -> Self {
+            let (q, bs, un): (u64, u64, u64);
+
+            unsafe {
+                core::arch::asm!(
+                    "ptrue p0.b, vl16",
+                    "ld1b {{z0.b}}, p0/z, [{ptr}]",
+
+                    // "
+                    "mov z1.b, #34",
+                    "match p1.b, p0/z, z0.b, z1.b",
+                    "brkb  p1.b, p0/z, p1.b",
+                    "cntp  {q_idx}, p0, p1.b",
+
+                    // /
+                    "mov z1.b, #92",
+                    "match p1.b, p0/z, z0.b, z1.b",
+                    "brkb  p1.b, p0/z, p1.b",
+                    "cntp  {bs_idx}, p0, p1.b",
+
+                    // ascii control characters
+                    "mov z1.b, #31",
+                    "cmple p1.b, p0/z, z0.b, z1.b",
+                    "brkb  p1.b, p0/z, p1.b",
+                    "cntp  {un_idx}, p0, p1.b",
+
+                    ptr = in(reg) ptr,
+                    q_idx = out(reg) q,
+                    bs_idx = out(reg) bs,
+                    un_idx = out(reg) un,
+                    out("z0") _, out("z1") _,
+                    out("p0") _, out("p1") _,
+                );
+            }
+
+            Self {
+                quote_bits: SveBits::new(q as usize),
+                bs_bits: SveBits::new(bs as usize),
+                unescaped_bits: SveBits::new(un as usize),
+            }
+        }
+    }
+
+    impl SVEStringBlock {
+        #[inline(always)]
+        pub fn has_unescaped(&self) -> bool {
+            self.unescaped_bits.0 < self.quote_bits.0
+        }
+
+        #[inline(always)]
+        pub fn has_quote_first(&self) -> bool {
+            self.quote_bits.0 < self.bs_bits.0 && !self.has_unescaped()
+        }
+
+        #[inline(always)]
+        pub fn has_backslash(&self) -> bool {
+            self.bs_bits.0 < self.quote_bits.0
+        }
+
+        #[inline(always)]
+        pub fn quote_index(&self) -> usize {
+            self.quote_bits.0
+        }
+    }
+
+    #[test]
+    fn test_sve_bits() {
+        let s = b"\"\\\t\n";
+        let block = SVEStringBlock::new_sve(s.as_ptr());
+        assert_eq!(block.quote_bits.0, 0);
+        assert_eq!(block.bs_bits.0, 1);
+        assert_eq!(block.unescaped_bits.0, 2);
+
+        let block = SVEStringBlock::new_sve(unsafe {
+            {
+                s.as_ptr().add(2)
+            }
+        });
+        assert_eq!(block.quote_bits.0, 16);
+        assert_eq!(block.bs_bits.0, 16);
+        assert_eq!(block.unescaped_bits.0, 0);
+    }
+}