cheetah-string 2.1.0

A lightweight, high-performance string manipulation library optimized for speed-sensitive applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

#![cfg(feature = "experimental-packed")]

use cheetah_string::packed::PackedCheetahString;
use cheetah_string::CheetahString;
use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput};
use std::collections::HashMap;

const TOPIC_COUNT: usize = 1_000;

fn short_topics() -> Vec<String> {
    (0..TOPIC_COUNT).map(|i| format!("T{:022}", i)).collect()
}

fn long_topics() -> Vec<String> {
    (0..TOPIC_COUNT)
        .map(|i| format!("RMQ_SYS_TRACE_TOPIC_{:05}_LONG_ROUTE_SEGMENT", i))
        .collect()
}

fn bench_packed_construction(c: &mut Criterion) {
    let short = "topic-a";
    let long = "RMQ_SYS_TRACE_TOPIC_00001_LONG_ROUTE_SEGMENT";

    let mut group = c.benchmark_group("packed_construction");

    group.bench_function("CheetahString short", |b| {
        b.iter(|| CheetahString::from(black_box(short)))
    });
    group.bench_function("PackedCheetahString short", |b| {
        b.iter(|| PackedCheetahString::from(black_box(short)))
    });
    group.bench_function("CheetahString long", |b| {
        b.iter(|| CheetahString::from(black_box(long)))
    });
    group.bench_function("PackedCheetahString long", |b| {
        b.iter(|| PackedCheetahString::from(black_box(long)))
    });

    group.finish();
}

fn bench_packed_push_str(c: &mut Criterion) {
    let mut group = c.benchmark_group("packed_push_str");

    group.bench_function("CheetahString inline append", |b| {
        b.iter(|| {
            let mut value = CheetahString::from("topic");
            value.push_str(black_box("-a"));
            black_box(value)
        })
    });
    group.bench_function("PackedCheetahString inline append", |b| {
        b.iter(|| {
            let mut value = PackedCheetahString::from("topic");
            value.push_str(black_box("-a"));
            black_box(value)
        })
    });
    group.bench_function("CheetahString promote to heap", |b| {
        b.iter(|| {
            let mut value = CheetahString::from("12345678901234567890123");
            value.push_str(black_box("-overflow"));
            black_box(value)
        })
    });
    group.bench_function("PackedCheetahString promote to heap", |b| {
        b.iter(|| {
            let mut value = PackedCheetahString::from("12345678901234567890123");
            value.push_str(black_box("-overflow"));
            black_box(value)
        })
    });

    group.finish();
}

fn bench_packed_topic_insert(c: &mut Criterion) {
    let short_topics = short_topics();
    let long_topics = long_topics();
    let mut group = c.benchmark_group("packed_mq_topic_insert");
    group.throughput(Throughput::Elements(TOPIC_COUNT as u64));

    group.bench_function("CheetahString short topics", |b| {
        b.iter(|| {
            let mut map = HashMap::with_capacity(TOPIC_COUNT);
            for (idx, topic) in short_topics.iter().enumerate() {
                map.insert(black_box(CheetahString::from(topic.as_str())), idx);
            }
            black_box(map)
        })
    });
    group.bench_function("PackedCheetahString short topics", |b| {
        b.iter(|| {
            let mut map = HashMap::with_capacity(TOPIC_COUNT);
            for (idx, topic) in short_topics.iter().enumerate() {
                map.insert(black_box(PackedCheetahString::from(topic.as_str())), idx);
            }
            black_box(map)
        })
    });
    group.bench_function("CheetahString long topics", |b| {
        b.iter(|| {
            let mut map = HashMap::with_capacity(TOPIC_COUNT);
            for (idx, topic) in long_topics.iter().enumerate() {
                map.insert(black_box(CheetahString::from(topic.as_str())), idx);
            }
            black_box(map)
        })
    });
    group.bench_function("PackedCheetahString long topics", |b| {
        b.iter(|| {
            let mut map = HashMap::with_capacity(TOPIC_COUNT);
            for (idx, topic) in long_topics.iter().enumerate() {
                map.insert(black_box(PackedCheetahString::from(topic.as_str())), idx);
            }
            black_box(map)
        })
    });

    group.finish();
}

criterion_group!(
    benches,
    bench_packed_construction,
    bench_packed_push_str,
    bench_packed_topic_insert
);
criterion_main!(benches);