str various refactor and perf

Cargo.toml

@@ -71,7 +71,7 @@ pyo3-ffi = { version = "^0.22", default-features = false, features = ["extension
 ryu = { version = "1", default-features = false }
 serde = { version = "1", default-features = false }
 serde_json = { version = "1", default-features = false, features = ["std", "float_roundtrip"] }
-simdutf8 = { version = "0.1", default-features = false, features = ["std", "aarch64_neon"] }
+simdutf8 = { version = "0.1", default-features = false, features = ["std", "public_imp", "aarch64_neon"] }
 smallvec = { version = "^1.11", default-features = false, features = ["union", "write"] }
 unwinding = { version = "0.2", features = ["unwinder"], optional = true }
 xxhash-rust = { version = "^0.8", default-features = false, features = ["xxh3"] }

build.rs

@@ -41,10 +41,6 @@ fn main() {
     if env::var("ORJSON_DISABLE_SIMD").is_err() {
         if let Some(true) = version_check::supports_feature("portable_simd") {
             println!("cargo:rustc-cfg=feature=\"unstable-simd\"");
-            #[cfg(all(target_arch = "x86_64", target_feature = "avx512vl"))]
-            if env::var("ORJSON_DISABLE_AVX512").is_err() {
-                println!("cargo:rustc-cfg=feature=\"avx512\"");
-            }
         }
     }
 

src/deserialize/utf8.rs

@@ -8,16 +8,16 @@ use crate::util::INVALID_STR;
 use core::ffi::c_char;
 use std::borrow::Cow;
 
-#[cfg(all(target_arch = "x86_64", not(target_feature = "sse4.2")))]
+#[cfg(all(target_arch = "x86_64", not(target_feature = "avx2")))]
 fn is_valid_utf8(buf: &[u8]) -> bool {
-    if std::is_x86_feature_detected!("sse4.2") {
-        simdutf8::basic::from_utf8(buf).is_ok()
+    if std::is_x86_feature_detected!("avx2") {
+        unsafe { simdutf8::basic::imp::x86::avx2::validate_utf8(buf).is_ok() }
     } else {
         encoding_rs::Encoding::utf8_valid_up_to(buf) == buf.len()
     }
 }
 
-#[cfg(all(target_arch = "x86_64", target_feature = "sse4.2"))]
+#[cfg(all(target_arch = "x86_64", target_feature = "avx2"))]
 fn is_valid_utf8(buf: &[u8]) -> bool {
     simdutf8::basic::from_utf8(buf).is_ok()
 }

src/lib.rs

@@ -1,13 +1,7 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-#![cfg_attr(
-    all(target_arch = "x86_64", feature = "avx512"),
-    feature(avx512_target_feature)
-)]
-#![cfg_attr(
-    all(target_arch = "x86_64", feature = "avx512"),
-    feature(stdarch_x86_avx512)
-)]
+#![cfg_attr(feature = "avx512", feature(avx512_target_feature))]
+#![cfg_attr(feature = "avx512", feature(stdarch_x86_avx512))]
 #![cfg_attr(feature = "intrinsics", feature(core_intrinsics))]
 #![cfg_attr(feature = "optimize", feature(optimize_attribute))]
 #![cfg_attr(feature = "strict_provenance", feature(strict_provenance))]

src/serialize/per_type/unicode.rs

@@ -17,16 +17,19 @@ impl StrSerializer {
 }
 
 impl Serialize for StrSerializer {
-    #[inline]
+    #[inline(always)]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
-        let uni = unicode_to_str(self.ptr);
-        if unlikely!(uni.is_none()) {
-            err!(SerializeError::InvalidStr)
-        }
-        serializer.serialize_str(uni.unwrap())
+        let uni = {
+            let tmp = unicode_to_str(self.ptr);
+            if unlikely!(tmp.is_none()) {
+                err!(SerializeError::InvalidStr)
+            };
+            tmp.unwrap()
+        };
+        serializer.serialize_str(uni)
     }
 }
 

src/serialize/writer/byteswriter.rs

@@ -113,6 +113,11 @@ pub trait WriteExt: std::io::Write {
         let _ = len;
     }
 
+    #[inline]
+    fn has_capacity(&mut self, _len: usize) -> bool {
+        false
+    }
+
     #[inline]
     fn set_written(&mut self, len: usize) {
         let _ = len;
@@ -157,6 +162,11 @@ impl WriteExt for &mut BytesWriter {
         }
     }
 
+    #[inline]
+    fn has_capacity(&mut self, len: usize) -> bool {
+        return self.len + len <= self.cap;
+    }
+
     #[inline(always)]
     fn set_written(&mut self, len: usize) {
         self.len += len;

src/serialize/writer/formatter.rs

@@ -4,6 +4,12 @@
 use crate::serialize::writer::WriteExt;
 use std::io;
 
+macro_rules! debug_assert_has_capacity {
+    ($writer:expr) => {
+        debug_assert!($writer.has_capacity(4))
+    };
+}
+
 pub trait Formatter {
     #[inline]
     fn write_null<W>(&mut self, writer: &mut W) -> io::Result<()>
@@ -196,7 +202,7 @@ pub trait Formatter {
     where
         W: ?Sized + io::Write + WriteExt,
     {
-        reserve_minimum!(writer);
+        debug_assert_has_capacity!(writer);
         unsafe { writer.write_reserved_punctuation(b']').unwrap() };
         Ok(())
     }
@@ -206,7 +212,7 @@ pub trait Formatter {
     where
         W: ?Sized + io::Write + WriteExt,
     {
-        reserve_minimum!(writer);
+        debug_assert_has_capacity!(writer);
         if !first {
             unsafe { writer.write_reserved_punctuation(b',').unwrap() }
         }
@@ -238,7 +244,7 @@ pub trait Formatter {
     where
         W: ?Sized + io::Write + WriteExt,
     {
-        reserve_minimum!(writer);
+        debug_assert_has_capacity!(writer);
         unsafe {
             writer.write_reserved_punctuation(b'}').unwrap();
         }
@@ -250,7 +256,7 @@ pub trait Formatter {
     where
         W: ?Sized + io::Write + WriteExt,
     {
-        reserve_minimum!(writer);
+        debug_assert_has_capacity!(writer);
         if !first {
             unsafe {
                 writer.write_reserved_punctuation(b',').unwrap();
@@ -272,7 +278,7 @@ pub trait Formatter {
     where
         W: ?Sized + io::Write + WriteExt,
     {
-        reserve_minimum!(writer);
+        debug_assert_has_capacity!(writer);
         unsafe { writer.write_reserved_punctuation(b':') }
     }
 

src/serialize/writer/json.rs

@@ -572,9 +572,29 @@ macro_rules! reserve_str {
     };
 }
 
+#[cfg(all(feature = "unstable-simd", not(target_arch = "x86_64")))]
+#[inline(always)]
+fn format_escaped_str<W>(writer: &mut W, value: &str)
+where
+    W: ?Sized + io::Write + WriteExt,
+{
+    unsafe {
+        reserve_str!(writer, value);
+
+        let written = format_escaped_str_impl_generic_128(
+            writer.as_mut_buffer_ptr(),
+            value.as_bytes().as_ptr(),
+            value.len(),
+        );
+
+        writer.set_written(written);
+    }
+}
+
 #[cfg(all(
     feature = "unstable-simd",
-    any(not(target_arch = "x86_64"), not(feature = "avx512"))
+    target_arch = "x86_64",
+    not(feature = "avx512")
 ))]
 #[inline(always)]
 fn format_escaped_str<W>(writer: &mut W, value: &str)
@@ -584,7 +604,7 @@ where
     unsafe {
         reserve_str!(writer, value);
 
-        let written = format_escaped_str_impl_128(
+        let written = format_escaped_str_impl_generic_128(
             writer.as_mut_buffer_ptr(),
             value.as_bytes().as_ptr(),
             value.len(),
@@ -611,7 +631,7 @@ where
             );
             writer.set_written(written);
         } else {
-            let written = format_escaped_str_impl_128(
+            let written = format_escaped_str_impl_generic_128(
                 writer.as_mut_buffer_ptr(),
                 value.as_bytes().as_ptr(),
                 value.len(),

src/serialize/writer/mod.rs

@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 mod byteswriter;
 mod formatter;