Why not use 32 as INLINE_CAP?

[paulip1792]

Since size of largest variant Bytes is already 32, why not use 32 as INLINE_CAP? Is there any performance reason?

[PureWhiteWu]

You may refer to rust-lang/rust#119247

[paulip1792]

use bytes::Bytes;
use criterion::{black_box, criterion_group, criterion_main, Criterion};
use std::sync::Arc;

#[derive(Clone)]
enum Repr<T, const INLINE_CAP: usize> {
    Empty,
    Bytes(Bytes),
    ArcStr(Arc<str>),
    ArcString(Arc<String>),
    StaticStr(&'static str),
    Inline(ArrayString<T, INLINE_CAP>),
}

#[derive(Clone)]
pub struct ArrayString<T, const INLINE_CAP: usize> {
    buf: [u8; INLINE_CAP],
    len: T,
}

fn criterion_benchmark(c: &mut Criterion) {
    let s: Repr<u8, 38> = Repr::Empty;
    assert_eq!(size_of_val(&s), 40);
    c.bench_function("empty repr (u8, 38)", |b| b.iter(|| black_box(s.clone())));

    let s: Repr<u32, 32> = Repr::Empty;
    assert_eq!(size_of_val(&s), 40);
    c.bench_function("empty repr (u32, 32)", |b| b.iter(|| black_box(s.clone())));

    let s: Repr<u32, 24> = Repr::Empty;
    assert_eq!(size_of_val(&s), 40);
    c.bench_function("empty repr (u32, 24)", |b| b.iter(|| black_box(s.clone())));

    let s: Repr<usize, 24> = Repr::Empty;
    assert_eq!(size_of_val(&s), 40);
    c.bench_function("empty repr (usize, 24)", |b| {
        b.iter(|| black_box(s.clone()))
    });
}

criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);

empty repr (u8, 38)     time:   [31.685 ns 31.697 ns 31.710 ns]
                        change: [-0.0830% -0.0242% +0.0351%] (p = 0.43 > 0.05)
                        No change in performance detected.
Found 4 outliers among 100 measurements (4.00%)
  1 (1.00%) low mild
  3 (3.00%) high mild

empty repr (u32, 32)    time:   [5.7327 ns 5.7403 ns 5.7526 ns]
                        change: [+0.0037% +0.1318% +0.3324%] (p = 0.10 > 0.05)
                        No change in performance detected.
Found 5 outliers among 100 measurements (5.00%)
  1 (1.00%) low mild
  2 (2.00%) high mild
  2 (2.00%) high severe

empty repr (u32, 24)    time:   [5.7343 ns 5.7354 ns 5.7368 ns]
                        change: [+0.0190% +0.0486% +0.0802%] (p = 0.00 < 0.05)
                        Change within noise threshold.
Found 11 outliers among 100 measurements (11.00%)
  1 (1.00%) low mild
  3 (3.00%) high mild
  7 (7.00%) high severe

empty repr (usize, 24)  time:   [3.0021 ns 3.0024 ns 3.0026 ns]
                        change: [-0.0654% -0.0418% -0.0217%] (p = 0.00 < 0.05)
                        Change within noise threshold.
Found 4 outliers among 100 measurements (4.00%)
  3 (3.00%) low mild
  1 (1.00%) high severe

This is my benchmark result. I think maybe we can provide a GenericFastStr<T, const INLINE_CAP> and pub type FastStr = GenericFastStr<usize, 24> so that we can get extra cap if needed?