Merge pull request #119 from mxsm/codex/pr-006-mutation-fast-paths

Enh: Reuse mutation fast paths

Author: mxsm

Cargo.toml

@@ -42,6 +42,10 @@ harness = false
 name = "layout"
 harness = false
 
+[[bench]]
+name = "mutation"
+harness = false
+
 [[bench]]
 name = "pattern"
 harness = false

benches/mutation.rs

@@ -0,0 +1,83 @@
+use cheetah_string::CheetahString;
+use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+
+fn bench_push_str(c: &mut Criterion) {
+    let mut group = c.benchmark_group("push_str");
+
+    group.bench_function("inline_in_place", |b| {
+        b.iter(|| {
+            let mut s = CheetahString::from("hello");
+            s.push_str(black_box(" world"));
+            black_box(s)
+        })
+    });
+
+    group.bench_function("owned_spare_capacity", |b| {
+        b.iter(|| {
+            let mut s = CheetahString::with_capacity(128);
+            s.push_str("hello");
+            s.push_str(black_box(" world"));
+            black_box(s)
+        })
+    });
+
+    group.bench_function("static_fallback", |b| {
+        b.iter(|| {
+            let mut s = CheetahString::from_static_str("hello");
+            s.push_str(black_box(" world"));
+            black_box(s)
+        })
+    });
+
+    group.finish();
+}
+
+fn bench_add(c: &mut Criterion) {
+    let mut group = c.benchmark_group("add");
+
+    for rhs_len in [1, 8, 32, 128] {
+        let rhs = "x".repeat(rhs_len);
+
+        group.bench_with_input(
+            BenchmarkId::new("owned_capacity_str", rhs_len),
+            &rhs,
+            |b, rhs| {
+                b.iter(|| {
+                    let mut s = CheetahString::with_capacity(256);
+                    s.push_str("hello");
+                    black_box(s + black_box(rhs.as_str()))
+                })
+            },
+        );
+
+        group.bench_with_input(BenchmarkId::new("inline_str", rhs_len), &rhs, |b, rhs| {
+            b.iter(|| black_box(CheetahString::from("h") + black_box(rhs.as_str())))
+        });
+    }
+
+    group.finish();
+}
+
+fn bench_reserve(c: &mut Criterion) {
+    let mut group = c.benchmark_group("reserve");
+
+    for additional in [0, 8, 128] {
+        group.bench_with_input(
+            BenchmarkId::from_parameter(additional),
+            &additional,
+            |b, extra| {
+                b.iter(|| {
+                    let mut s = CheetahString::with_capacity(64);
+                    s.push_str("hello");
+                    s.reserve(black_box(*extra));
+                    black_box(s)
+                })
+            },
+        );
+    }
+
+    group.finish();
+}
+
+criterion_group!(benches, bench_push_str, bench_add, bench_reserve);
+criterion_main!(benches);

scripts/bench-all.ps1

@@ -12,6 +12,9 @@ cargo bench --bench layout |
 cargo bench --bench comprehensive |
     Tee-Object -FilePath (Join-Path $ResultDir "comprehensive.txt")
 
+cargo bench --bench mutation |
+    Tee-Object -FilePath (Join-Path $ResultDir "mutation.txt")
+
 cargo bench --bench pattern |
     Tee-Object -FilePath (Join-Path $ResultDir "pattern.txt")
 

scripts/bench-all.sh

@@ -9,5 +9,6 @@ mkdir -p "$RESULT_DIR"
 cargo test layout_snapshot --all-features -- --nocapture | tee "$RESULT_DIR/layout-test.txt"
 cargo bench --bench layout | tee "$RESULT_DIR/layout-bench.txt"
 cargo bench --bench comprehensive | tee "$RESULT_DIR/comprehensive.txt"
+cargo bench --bench mutation | tee "$RESULT_DIR/mutation.txt"
 cargo bench --bench pattern | tee "$RESULT_DIR/pattern.txt"
 cargo bench --bench simd --features simd | tee "$RESULT_DIR/simd.txt"

src/cheetah_string.rs

@@ -972,6 +972,10 @@ impl CheetahString {
 
     #[inline]
     fn push_str_internal(&mut self, string: &str) {
+        if string.is_empty() {
+            return;
+        }
+
         match &mut self.inner {
             InnerString::Inline { len, data } => {
                 let total_len = *len as usize + string.len();
@@ -1039,6 +1043,10 @@ impl CheetahString {
     /// ```
     #[inline]
     pub fn reserve(&mut self, additional: usize) {
+        if additional == 0 {
+            return;
+        }
+
         match &mut self.inner {
             InnerString::Inline { len, .. } if *len as usize + additional <= INLINE_CAPACITY => {
                 return;
@@ -1202,28 +1210,9 @@ impl Add<&str> for CheetahString {
     /// assert_eq!(result, "Hello World");
     /// ```
     #[inline]
-    fn add(self, rhs: &str) -> Self::Output {
-        let total_len = self.len() + rhs.len();
-
-        // Fast path: result fits in inline storage
-        if total_len <= INLINE_CAPACITY {
-            let mut data = [0u8; INLINE_CAPACITY];
-            let self_bytes = self.as_bytes();
-            data[..self_bytes.len()].copy_from_slice(self_bytes);
-            data[self_bytes.len()..total_len].copy_from_slice(rhs.as_bytes());
-            return CheetahString {
-                inner: InnerString::Inline {
-                    len: total_len as u8,
-                    data,
-                },
-            };
-        }
-
-        // Slow path: allocate for long result
-        let mut result = String::with_capacity(total_len);
-        result.push_str(self.as_str());
-        result.push_str(rhs);
-        CheetahString::from_string(result)
+    fn add(mut self, rhs: &str) -> Self::Output {
+        self.push_str_internal(rhs);
+        self
     }
 }
 
@@ -1243,28 +1232,9 @@ impl Add<&CheetahString> for CheetahString {
     /// assert_eq!(result, "Hello World");
     /// ```
     #[inline]
-    fn add(self, rhs: &CheetahString) -> Self::Output {
-        let total_len = self.len() + rhs.len();
-
-        // Fast path: result fits in inline storage
-        if total_len <= INLINE_CAPACITY {
-            let mut data = [0u8; INLINE_CAPACITY];
-            let self_bytes = self.as_bytes();
-            data[..self_bytes.len()].copy_from_slice(self_bytes);
-            data[self_bytes.len()..total_len].copy_from_slice(rhs.as_bytes());
-            return CheetahString {
-                inner: InnerString::Inline {
-                    len: total_len as u8,
-                    data,
-                },
-            };
-        }
-
-        // Slow path: allocate for long result
-        let mut result = String::with_capacity(total_len);
-        result.push_str(self.as_str());
-        result.push_str(rhs.as_str());
-        CheetahString::from_string(result)
+    fn add(mut self, rhs: &CheetahString) -> Self::Output {
+        self.push_str_internal(rhs.as_str());
+        self
     }
 }
 
@@ -1283,28 +1253,13 @@ impl Add<String> for CheetahString {
     /// assert_eq!(result, "Hello World");
     /// ```
     #[inline]
-    fn add(self, rhs: String) -> Self::Output {
-        let total_len = self.len() + rhs.len();
-
-        // Fast path: result fits in inline storage
-        if total_len <= INLINE_CAPACITY {
-            let mut data = [0u8; INLINE_CAPACITY];
-            let self_bytes = self.as_bytes();
-            data[..self_bytes.len()].copy_from_slice(self_bytes);
-            data[self_bytes.len()..total_len].copy_from_slice(rhs.as_bytes());
-            return CheetahString {
-                inner: InnerString::Inline {
-                    len: total_len as u8,
-                    data,
-                },
-            };
+    fn add(mut self, rhs: String) -> Self::Output {
+        if self.is_empty() {
+            return CheetahString::from_string(rhs);
         }
 
-        // Slow path: allocate for long result
-        let mut result = String::with_capacity(total_len);
-        result.push_str(self.as_str());
-        result.push_str(&rhs);
-        CheetahString::from_string(result)
+        self.push_str_internal(&rhs);
+        self
     }
 }
 

tests/mutation.rs

@@ -0,0 +1,60 @@
+use cheetah_string::CheetahString;
+
+#[test]
+fn inline_push_str_appends_in_place() {
+    let mut s = CheetahString::from("hello");
+    let before = s.as_bytes().as_ptr();
+
+    s.push_str(" world");
+
+    assert_eq!(s, "hello world");
+    assert_eq!(s.as_bytes().as_ptr(), before);
+}
+
+#[test]
+fn owned_push_str_reuses_spare_capacity() {
+    let mut s = CheetahString::with_capacity(128);
+    s.push_str("hello");
+    let before = s.as_bytes().as_ptr();
+
+    s.push_str(" world");
+
+    assert_eq!(s, "hello world");
+    assert_eq!(s.as_bytes().as_ptr(), before);
+}
+
+#[test]
+fn add_reuses_owned_lhs_capacity() {
+    let mut s = CheetahString::with_capacity(128);
+    s.push_str("hello");
+    let before = s.as_bytes().as_ptr();
+
+    let s = s + " world";
+
+    assert_eq!(s, "hello world");
+    assert_eq!(s.as_bytes().as_ptr(), before);
+}
+
+#[test]
+fn reserve_zero_keeps_existing_buffer() {
+    let mut s = CheetahString::with_capacity(128);
+    s.push_str("hello");
+    let before = s.as_bytes().as_ptr();
+
+    s.reserve(0);
+
+    assert_eq!(s, "hello");
+    assert_eq!(s.as_bytes().as_ptr(), before);
+}
+
+#[test]
+fn add_assign_uses_push_str_path() {
+    let mut s = CheetahString::with_capacity(128);
+    s.push_str("hello");
+    let before = s.as_bytes().as_ptr();
+
+    s += " world";
+
+    assert_eq!(s, "hello world");
+    assert_eq!(s.as_bytes().as_ptr(), before);
+}