wacore-binary 0.6.0

Binary data and constants for WhatsApp protocol
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

use iai_callgrind::{
    Callgrind, LibraryBenchmarkConfig, library_benchmark, library_benchmark_group, main,
};
use std::hint::black_box;

use compact_str::CompactString;
use wacore_binary::node::NodeValue;

/// Baseline: what the codebase does today — `value.to_string()` then Into<NodeValue>.
/// Heap-allocates a `String`, then `CompactString::from(String)` re-uses or copies.
#[inline(never)]
fn baseline_u32(n: u32) -> NodeValue {
    NodeValue::from(n.to_string())
}

#[inline(never)]
fn baseline_u64(n: u64) -> NodeValue {
    NodeValue::from(n.to_string())
}

#[inline(never)]
fn baseline_i64(n: i64) -> NodeValue {
    NodeValue::from(n.to_string())
}

/// Proposed path: use `itoa` to format into a stack buffer, then `CompactString::from(&str)`
/// which inlines for strings <= 24 bytes on 64-bit (all integers fit).
#[inline(never)]
fn proposed_u32(n: u32) -> NodeValue {
    let mut buf = itoa::Buffer::new();
    NodeValue::String(CompactString::from(buf.format(n)))
}

#[inline(never)]
fn proposed_u64(n: u64) -> NodeValue {
    let mut buf = itoa::Buffer::new();
    NodeValue::String(CompactString::from(buf.format(n)))
}

#[inline(never)]
fn proposed_i64(n: i64) -> NodeValue {
    let mut buf = itoa::Buffer::new();
    NodeValue::String(CompactString::from(buf.format(n)))
}

#[library_benchmark]
fn bench_baseline_u32() -> NodeValue {
    black_box(baseline_u32(black_box(12345)))
}

#[library_benchmark]
fn bench_proposed_u32() -> NodeValue {
    black_box(proposed_u32(black_box(12345)))
}

#[library_benchmark]
fn bench_baseline_u64() -> NodeValue {
    black_box(baseline_u64(black_box(1234567890123u64)))
}

#[library_benchmark]
fn bench_proposed_u64() -> NodeValue {
    black_box(proposed_u64(black_box(1234567890123u64)))
}

#[library_benchmark]
fn bench_baseline_i64() -> NodeValue {
    black_box(baseline_i64(black_box(-1234567890123i64)))
}

#[library_benchmark]
fn bench_proposed_i64() -> NodeValue {
    black_box(proposed_i64(black_box(-1234567890123i64)))
}

#[library_benchmark]
fn bench_baseline_loop_100_u64() -> u64 {
    let mut acc: u64 = 0;
    for i in 0u64..100 {
        let v = baseline_u64(black_box(100_000 + i));
        acc = acc.wrapping_add(v.as_str().len() as u64);
    }
    black_box(acc)
}

#[library_benchmark]
fn bench_proposed_loop_100_u64() -> u64 {
    let mut acc: u64 = 0;
    for i in 0u64..100 {
        let v = proposed_u64(black_box(100_000 + i));
        acc = acc.wrapping_add(v.as_str().len() as u64);
    }
    black_box(acc)
}

library_benchmark_group!(
    name = bench_group;
    benchmarks =
        bench_baseline_u32,
        bench_proposed_u32,
        bench_baseline_u64,
        bench_proposed_u64,
        bench_baseline_i64,
        bench_proposed_i64,
        bench_baseline_loop_100_u64,
        bench_proposed_loop_100_u64,
);

main!(
    config = LibraryBenchmarkConfig::default()
        .tool(Callgrind::default());
    library_benchmark_groups = bench_group
);