upgrade benches

Author: tomtomwombat

Cargo.lock

@@ -1,19 +1,23 @@
 [package]
-name = "benches"
+name = "bench"
 publish = false
 version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+fastrand = "2.3.0"
+
+[dev-dependencies]
 cold-string = { path = "../cold-string" }
 criterion = "0.5"
-rand = "0.8"
 sysinfo = "0.38.2"
-fastrand = "2.3.0"
+ahash = "0.8.12"
 
 compact_string = "0.1.0"
 smol_str = "0.3.5"
 compact_str = "0.9.0"
+smartstring = "1.0.1"
+smallstr = "0.3.1"
 
 [[bench]]
 name = "bench"

bench/Cargo.toml

@@ -1,57 +1,123 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use criterion::{
+    black_box, criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, Criterion,
+};
 use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
+use std::str::FromStr;
 
+use bench::*;
 use cold_string::ColdString;
 
 const SHORT: &str = "qwerty";
 const LONG: &str = "this_is_a_longer_string_that_will_allocate";
 
-fn bench_construction(c: &mut Criterion) {
-    let mut group = c.benchmark_group("construction");
-
-    group.bench_function("ColdString short", |b| {
-        b.iter(|| black_box(ColdString::from(black_box(SHORT))))
-    });
-
-    group.bench_function("String short", |b| {
-        b.iter(|| black_box(String::from(black_box(SHORT))))
-    });
-
-    group.bench_function("ColdString long", |b| {
-        b.iter(|| black_box(ColdString::from(black_box(LONG))))
-    });
-
-    group.bench_function("String long", |b| {
-        b.iter(|| black_box(String::from(black_box(LONG))))
+const LENGTHS: &[usize] = &[4, 8, 16, 32, 64];
+
+fn bench_construction_inner<T: FromStr>(
+    g: &mut BenchmarkGroup<'_, WallTime>,
+    name: &'static str,
+    min: usize,
+    max: usize,
+    strings: &[String],
+) {
+    let label = format!("{}-len={}-{}", name, min, max);
+    g.bench_function(&label, |b| {
+        b.iter(|| {
+            for x in strings.iter() {
+                let _ = black_box(T::from_str(black_box(x.as_str())));
+            }
+        })
     });
+}
 
+#[rustfmt::skip]
+fn bench_construction(c: &mut Criterion) {
+    let mut group = c.benchmark_group("construction");
+    for len in LENGTHS {
+        for min in [0, *len] {
+            let mut strings = Vec::with_capacity(1000);
+            for _ in 0..1000 {
+                strings.push(random_string(min, *len));
+            }
+            bench_construction_inner::<String>(&mut group, "std", min, *len, &strings);
+            bench_construction_inner::<smol_str::SmolStr>(&mut group, "smol_str", min, *len, &strings);
+            bench_construction_inner::<compact_str::CompactString>(&mut group, "compact_str", min, *len, &strings);
+            bench_construction_inner::<smartstring::alias::String>(&mut group, "smartstring", min, *len, &strings);
+            bench_construction_inner::<smallstr::SmallString<[u8; 8]>>(&mut group, "smallstr", min, *len, &strings);
+            bench_construction_inner::<compact_string::CompactString>(&mut group, "compact_string", min, *len, &strings);
+            bench_construction_inner::<cold_string::ColdString>(&mut group, "cold-string", min, *len, &strings);
+        }
+    }
     group.finish();
 }
 
 fn bench_len(c: &mut Criterion) {
     let cold = ColdString::from(LONG);
     let string = String::from(LONG);
-
     let mut group = c.benchmark_group("len");
-
     group.bench_function("ColdString len", |b| b.iter(|| black_box(cold.len())));
-
     group.bench_function("String len", |b| b.iter(|| black_box(string.len())));
-
     group.finish();
 }
 
-fn bench_as_str(c: &mut Criterion) {
-    let cold = ColdString::from(LONG);
-    let string = String::from(LONG);
+fn bench_as_str_inner<T: FromStr + AsRef<str>>(
+    g: &mut BenchmarkGroup<'_, WallTime>,
+    name: &'static str,
+    min: usize,
+    max: usize,
+    strings: &[String],
+    indices: &[usize], // Pass pre-shuffled indices
+) {
+    // Pre-convert to the target type
+    let strings: Vec<_> = strings.iter()
+        .map(|s| T::from_str(s).map_err(|_| ()).unwrap())
+        .collect();
+    
+    let strings = black_box(strings);
+    let label = format!("{}-len={}-{}", name, min, max);
+
+    g.bench_function(&label, |b| {
+        b.iter(|| {
+            let mut sum: u8 = 0;
+            // Iterate using the shuffled indices to force cache misses
+            for &i in indices.iter() {
+                let s = &strings[i];
+                let x: &str = black_box(s).as_ref();
+                // Accessing the data is crucial to force the dereference
+                sum ^= x.as_bytes().first().unwrap_or(&0);
+            }
+            black_box(sum)
+        })
+    });
+}
 
+#[rustfmt::skip]
+fn bench_as_str(c: &mut Criterion) {
     let mut group = c.benchmark_group("as_str");
-
-    group.bench_function("ColdString as_str", |b| b.iter(|| black_box(cold.as_str())));
-
-    group.bench_function("String as_str", |b| b.iter(|| black_box(string.as_str())));
-
+    let count = 1_000_000;
+    
+    // Pre-calculate random indices once to keep the comparison fair across crates
+    let mut indices: Vec<usize> = (0..count).collect();
+    fastrand::shuffle(&mut indices);
+    // Limit to a subset if 1M iterations inside b.iter is too slow
+    let indices_subset = &indices[..1000]; 
+
+    for len in LENGTHS {
+        for min in [0, *len] {
+            let mut strings = Vec::with_capacity(count);
+            for _ in 0..count {
+                strings.push(random_string(min, *len));
+            }
+
+            bench_as_str_inner::<String>(&mut group, "std", min, *len, &strings, indices_subset);
+            bench_as_str_inner::<smol_str::SmolStr>(&mut group, "smol_str", min, *len, &strings, indices_subset);
+            bench_as_str_inner::<compact_str::CompactString>(&mut group, "compact_str", min, *len, &strings, indices_subset);
+            bench_as_str_inner::<smartstring::alias::String>(&mut group, "smartstring", min, *len, &strings, indices_subset);
+            bench_as_str_inner::<smallstr::SmallString<[u8; 8]>>(&mut group, "smallstr", min, *len, &strings, indices_subset);
+            bench_as_str_inner::<compact_string::CompactString>(&mut group, "compact_string", min, *len, &strings, indices_subset);
+            bench_as_str_inner::<cold_string::ColdString>(&mut group, "cold-string", min, *len, &strings, indices_subset);
+        }
+    }
     group.finish();
 }