perf: reduce allocation on x86

Author: Brooooooklyn

src/generic.rs

@@ -1,17 +1,20 @@
 #[inline]
-// Slightly modified version of
-// <https://github.com/serde-rs/json/blob/d12e943590208da738c092db92c34b39796a2538/src/ser.rs#L2079>
-// Borrowed from:
-// <https://github.com/oxc-project/oxc-sourcemap/blob/e533e6ca4d08c538d8d4df74eacd29437851591f/src/encode.rs#L331>
 pub fn escape_generic<S: AsRef<str>>(s: S) -> String {
     let s = s.as_ref();
     let bytes = s.as_bytes();
-
     // Estimate capacity - most strings don't need much escaping
     // Add some padding for potential escapes
     let estimated_capacity = bytes.len() + bytes.len() / 2 + 2;
-    let mut result = Vec::with_capacity(estimated_capacity);
+    let result = Vec::with_capacity(estimated_capacity);
+    escape_inner(bytes, result)
+}
 
+#[inline]
+// Slightly modified version of
+// <https://github.com/serde-rs/json/blob/d12e943590208da738c092db92c34b39796a2538/src/ser.rs#L2079>
+// Borrowed from:
+// <https://github.com/oxc-project/oxc-sourcemap/blob/e533e6ca4d08c538d8d4df74eacd29437851591f/src/encode.rs#L331>
+pub(crate) fn escape_inner(bytes: &[u8], mut result: Vec<u8>) -> String {
     result.push(b'"');
 
     let mut start = 0;

src/lib.rs

@@ -121,15 +121,20 @@ pub use generic::escape_generic;
 pub fn escape<S: AsRef<str>>(input: S) -> String {
     #[cfg(target_arch = "x86_64")]
     {
+        use generic::escape_inner;
+
+        let result = Vec::with_capacity(input.as_ref().len() + input.as_ref().len() / 2 + 2);
+        let s = input.as_ref();
+        let bytes = s.as_bytes();
         // Runtime CPU feature detection for x86_64
         if is_x86_feature_detected!("avx512f") && is_x86_feature_detected!("avx512bw") {
-            unsafe { return x86::escape_avx512(input) }
+            unsafe { return x86::escape_avx512(bytes, result) }
         } else if is_x86_feature_detected!("avx2") {
-            unsafe { return x86::escape_avx2(input) }
+            unsafe { return x86::escape_avx2(bytes, result) }
         } else if is_x86_feature_detected!("sse2") {
-            unsafe { return x86::escape_sse2(input) }
+            unsafe { return x86::escape_sse2(bytes, result) }
         } else {
-            return escape_generic(input);
+            return escape_inner(bytes, result);
         }
     }
 

src/x86.rs

@@ -31,15 +31,9 @@ fn sub(a: *const u8, b: *const u8) -> usize {
 
 #[target_feature(enable = "avx512f", enable = "avx512bw")]
 #[inline]
-pub unsafe fn escape_avx512<S: AsRef<str>>(input: S) -> String {
-    let s = input.as_ref();
-    let bytes = s.as_bytes();
+pub unsafe fn escape_avx512(bytes: &[u8], mut result: Vec<u8>) -> String {
     let len = bytes.len();
 
-    // Pre-allocate with estimated capacity
-    let estimated_capacity = len + len / 2 + 2;
-    let mut result = Vec::with_capacity(estimated_capacity);
-
     result.push(b'"');
 
     let start_ptr = bytes.as_ptr();
@@ -237,7 +231,7 @@ pub unsafe fn escape_avx512<S: AsRef<str>>(input: S) -> String {
         }
     } else {
         // Fall back to AVX2 for small strings
-        return escape_avx2(input);
+        return escape_avx2(bytes, result);
     }
 
     // Copy any remaining bytes
@@ -251,15 +245,9 @@ pub unsafe fn escape_avx512<S: AsRef<str>>(input: S) -> String {
 
 #[target_feature(enable = "avx2")]
 #[inline]
-pub unsafe fn escape_avx2<S: AsRef<str>>(input: S) -> String {
-    let s = input.as_ref();
-    let bytes = s.as_bytes();
+pub unsafe fn escape_avx2(bytes: &[u8], mut result: Vec<u8>) -> String {
     let len = bytes.len();
 
-    // Pre-allocate with estimated capacity
-    let estimated_capacity = len + len / 2 + 2;
-    let mut result = Vec::with_capacity(estimated_capacity);
-
     result.push(b'"');
 
     let start_ptr = bytes.as_ptr();
@@ -477,7 +465,7 @@ pub unsafe fn escape_avx2<S: AsRef<str>>(input: S) -> String {
         }
     } else {
         // Fall back to SSE2 for small strings
-        return escape_sse2(input);
+        return escape_sse2(bytes, result);
     }
 
     // Copy any remaining bytes
@@ -491,14 +479,9 @@ pub unsafe fn escape_avx2<S: AsRef<str>>(input: S) -> String {
 
 #[target_feature(enable = "sse2")]
 #[inline]
-pub unsafe fn escape_sse2<S: AsRef<str>>(input: S) -> String {
-    let s = input.as_ref();
-    let bytes = s.as_bytes();
+pub unsafe fn escape_sse2(bytes: &[u8], mut result: Vec<u8>) -> String {
     let len = bytes.len();
 
-    let estimated_capacity = len + len / 2 + 2;
-    let mut result = Vec::with_capacity(estimated_capacity);
-
     result.push(b'"');
 
     let start_ptr = bytes.as_ptr();