ucobs 0.3.2

μCOBS — Consistent Overhead Byte Stuffing. no_std, zero-alloc, fastest, most-tested COBS implementation.
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271

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

// ── Test payloads ───────────────────────────────────────────────────

fn zeros(n: usize) -> Vec<u8> {
    vec![0u8; n]
}

fn nonzero(n: usize) -> Vec<u8> {
    (0..n).map(|i| (i % 255 + 1) as u8).collect()
}

fn mixed(n: usize) -> Vec<u8> {
    (0..n).map(|i| (i % 256) as u8).collect()
}

// ── Setup helpers ───────────────────────────────────────────────────

fn setup_encode(data: Vec<u8>) -> (Vec<u8>, Vec<u8>) {
    let buf = vec![0u8; ucobs::max_encoded_len(data.len()) + 1];
    (data, buf)
}

fn setup_decode_ucobs(data: Vec<u8>) -> (Vec<u8>, Vec<u8>) {
    let mut enc = vec![0u8; ucobs::max_encoded_len(data.len()) + 1];
    let n = ucobs::encode(&data, &mut enc).unwrap();
    enc.truncate(n);
    let dec = vec![0u8; data.len() + 1];
    (enc, dec)
}

fn setup_encode_corncobs(data: Vec<u8>) -> (Vec<u8>, Vec<u8>) {
    let buf = vec![0u8; corncobs::max_encoded_len(data.len())];
    (data, buf)
}

fn setup_decode_corncobs(data: Vec<u8>) -> (Vec<u8>, Vec<u8>) {
    let mut enc = vec![0u8; corncobs::max_encoded_len(data.len())];
    let n = corncobs::encode_buf(&data, &mut enc);
    enc.truncate(n);
    let dec = vec![0u8; data.len() + 1];
    (enc, dec)
}

fn setup_encode_cobs(data: Vec<u8>) -> (Vec<u8>, Vec<u8>) {
    let buf = vec![0u8; cobs::max_encoding_length(data.len())];
    (data, buf)
}

fn setup_decode_cobs(data: Vec<u8>) -> (Vec<u8>, Vec<u8>) {
    let mut enc = vec![0u8; cobs::max_encoding_length(data.len())];
    let n = cobs::encode(&data, &mut enc);
    enc.truncate(n);
    let dec = vec![0u8; data.len() + 1];
    (enc, dec)
}

// ── Encode benchmarks ──────────────────────────────────────────────

#[library_benchmark]
#[bench::zeros_0(setup_encode(zeros(0)))]
#[bench::zeros_1(setup_encode(zeros(1)))]
#[bench::zeros_10(setup_encode(zeros(10)))]
#[bench::zeros_64(setup_encode(zeros(64)))]
#[bench::zeros_254(setup_encode(zeros(254)))]
#[bench::zeros_255(setup_encode(zeros(255)))]
#[bench::zeros_256(setup_encode(zeros(256)))]
#[bench::zeros_1024(setup_encode(zeros(1024)))]
#[bench::zeros_4096(setup_encode(zeros(4096)))]
#[bench::nonzero_0(setup_encode(nonzero(0)))]
#[bench::nonzero_1(setup_encode(nonzero(1)))]
#[bench::nonzero_10(setup_encode(nonzero(10)))]
#[bench::nonzero_64(setup_encode(nonzero(64)))]
#[bench::nonzero_254(setup_encode(nonzero(254)))]
#[bench::nonzero_255(setup_encode(nonzero(255)))]
#[bench::nonzero_256(setup_encode(nonzero(256)))]
#[bench::nonzero_1024(setup_encode(nonzero(1024)))]
#[bench::nonzero_4096(setup_encode(nonzero(4096)))]
#[bench::mixed_0(setup_encode(mixed(0)))]
#[bench::mixed_1(setup_encode(mixed(1)))]
#[bench::mixed_10(setup_encode(mixed(10)))]
#[bench::mixed_64(setup_encode(mixed(64)))]
#[bench::mixed_254(setup_encode(mixed(254)))]
#[bench::mixed_255(setup_encode(mixed(255)))]
#[bench::mixed_256(setup_encode(mixed(256)))]
#[bench::mixed_1024(setup_encode(mixed(1024)))]
#[bench::mixed_4096(setup_encode(mixed(4096)))]
fn encode_ucobs((data, mut buf): (Vec<u8>, Vec<u8>)) {
    black_box(ucobs::encode(black_box(&data), &mut buf));
}

#[library_benchmark]
#[bench::zeros_0(setup_encode_corncobs(zeros(0)))]
#[bench::zeros_1(setup_encode_corncobs(zeros(1)))]
#[bench::zeros_10(setup_encode_corncobs(zeros(10)))]
#[bench::zeros_64(setup_encode_corncobs(zeros(64)))]
#[bench::zeros_254(setup_encode_corncobs(zeros(254)))]
#[bench::zeros_255(setup_encode_corncobs(zeros(255)))]
#[bench::zeros_256(setup_encode_corncobs(zeros(256)))]
#[bench::zeros_1024(setup_encode_corncobs(zeros(1024)))]
#[bench::zeros_4096(setup_encode_corncobs(zeros(4096)))]
#[bench::nonzero_0(setup_encode_corncobs(nonzero(0)))]
#[bench::nonzero_1(setup_encode_corncobs(nonzero(1)))]
#[bench::nonzero_10(setup_encode_corncobs(nonzero(10)))]
#[bench::nonzero_64(setup_encode_corncobs(nonzero(64)))]
#[bench::nonzero_254(setup_encode_corncobs(nonzero(254)))]
#[bench::nonzero_255(setup_encode_corncobs(nonzero(255)))]
#[bench::nonzero_256(setup_encode_corncobs(nonzero(256)))]
#[bench::nonzero_1024(setup_encode_corncobs(nonzero(1024)))]
#[bench::nonzero_4096(setup_encode_corncobs(nonzero(4096)))]
#[bench::mixed_0(setup_encode_corncobs(mixed(0)))]
#[bench::mixed_1(setup_encode_corncobs(mixed(1)))]
#[bench::mixed_10(setup_encode_corncobs(mixed(10)))]
#[bench::mixed_64(setup_encode_corncobs(mixed(64)))]
#[bench::mixed_254(setup_encode_corncobs(mixed(254)))]
#[bench::mixed_255(setup_encode_corncobs(mixed(255)))]
#[bench::mixed_256(setup_encode_corncobs(mixed(256)))]
#[bench::mixed_1024(setup_encode_corncobs(mixed(1024)))]
#[bench::mixed_4096(setup_encode_corncobs(mixed(4096)))]
fn encode_corncobs((data, mut buf): (Vec<u8>, Vec<u8>)) {
    black_box(corncobs::encode_buf(black_box(&data), &mut buf));
}

#[library_benchmark]
#[bench::zeros_0(setup_encode_cobs(zeros(0)))]
#[bench::zeros_1(setup_encode_cobs(zeros(1)))]
#[bench::zeros_10(setup_encode_cobs(zeros(10)))]
#[bench::zeros_64(setup_encode_cobs(zeros(64)))]
#[bench::zeros_254(setup_encode_cobs(zeros(254)))]
#[bench::zeros_255(setup_encode_cobs(zeros(255)))]
#[bench::zeros_256(setup_encode_cobs(zeros(256)))]
#[bench::zeros_1024(setup_encode_cobs(zeros(1024)))]
#[bench::zeros_4096(setup_encode_cobs(zeros(4096)))]
#[bench::nonzero_0(setup_encode_cobs(nonzero(0)))]
#[bench::nonzero_1(setup_encode_cobs(nonzero(1)))]
#[bench::nonzero_10(setup_encode_cobs(nonzero(10)))]
#[bench::nonzero_64(setup_encode_cobs(nonzero(64)))]
#[bench::nonzero_254(setup_encode_cobs(nonzero(254)))]
#[bench::nonzero_255(setup_encode_cobs(nonzero(255)))]
#[bench::nonzero_256(setup_encode_cobs(nonzero(256)))]
#[bench::nonzero_1024(setup_encode_cobs(nonzero(1024)))]
#[bench::nonzero_4096(setup_encode_cobs(nonzero(4096)))]
#[bench::mixed_0(setup_encode_cobs(mixed(0)))]
#[bench::mixed_1(setup_encode_cobs(mixed(1)))]
#[bench::mixed_10(setup_encode_cobs(mixed(10)))]
#[bench::mixed_64(setup_encode_cobs(mixed(64)))]
#[bench::mixed_254(setup_encode_cobs(mixed(254)))]
#[bench::mixed_255(setup_encode_cobs(mixed(255)))]
#[bench::mixed_256(setup_encode_cobs(mixed(256)))]
#[bench::mixed_1024(setup_encode_cobs(mixed(1024)))]
#[bench::mixed_4096(setup_encode_cobs(mixed(4096)))]
fn encode_cobs((data, mut buf): (Vec<u8>, Vec<u8>)) {
    black_box(cobs::encode(black_box(&data), &mut buf));
}

// ── Decode benchmarks ──────────────────────────────────────────────

#[library_benchmark]
#[bench::zeros_0(setup_decode_ucobs(zeros(0)))]
#[bench::zeros_1(setup_decode_ucobs(zeros(1)))]
#[bench::zeros_10(setup_decode_ucobs(zeros(10)))]
#[bench::zeros_64(setup_decode_ucobs(zeros(64)))]
#[bench::zeros_254(setup_decode_ucobs(zeros(254)))]
#[bench::zeros_255(setup_decode_ucobs(zeros(255)))]
#[bench::zeros_256(setup_decode_ucobs(zeros(256)))]
#[bench::zeros_1024(setup_decode_ucobs(zeros(1024)))]
#[bench::zeros_4096(setup_decode_ucobs(zeros(4096)))]
#[bench::nonzero_0(setup_decode_ucobs(nonzero(0)))]
#[bench::nonzero_1(setup_decode_ucobs(nonzero(1)))]
#[bench::nonzero_10(setup_decode_ucobs(nonzero(10)))]
#[bench::nonzero_64(setup_decode_ucobs(nonzero(64)))]
#[bench::nonzero_254(setup_decode_ucobs(nonzero(254)))]
#[bench::nonzero_255(setup_decode_ucobs(nonzero(255)))]
#[bench::nonzero_256(setup_decode_ucobs(nonzero(256)))]
#[bench::nonzero_1024(setup_decode_ucobs(nonzero(1024)))]
#[bench::nonzero_4096(setup_decode_ucobs(nonzero(4096)))]
#[bench::mixed_0(setup_decode_ucobs(mixed(0)))]
#[bench::mixed_1(setup_decode_ucobs(mixed(1)))]
#[bench::mixed_10(setup_decode_ucobs(mixed(10)))]
#[bench::mixed_64(setup_decode_ucobs(mixed(64)))]
#[bench::mixed_254(setup_decode_ucobs(mixed(254)))]
#[bench::mixed_255(setup_decode_ucobs(mixed(255)))]
#[bench::mixed_256(setup_decode_ucobs(mixed(256)))]
#[bench::mixed_1024(setup_decode_ucobs(mixed(1024)))]
#[bench::mixed_4096(setup_decode_ucobs(mixed(4096)))]
fn decode_ucobs((enc, mut buf): (Vec<u8>, Vec<u8>)) {
    black_box(ucobs::decode(black_box(&enc), &mut buf));
}

#[library_benchmark]
#[bench::zeros_0(setup_decode_corncobs(zeros(0)))]
#[bench::zeros_1(setup_decode_corncobs(zeros(1)))]
#[bench::zeros_10(setup_decode_corncobs(zeros(10)))]
#[bench::zeros_64(setup_decode_corncobs(zeros(64)))]
#[bench::zeros_254(setup_decode_corncobs(zeros(254)))]
#[bench::zeros_255(setup_decode_corncobs(zeros(255)))]
#[bench::zeros_256(setup_decode_corncobs(zeros(256)))]
#[bench::zeros_1024(setup_decode_corncobs(zeros(1024)))]
#[bench::zeros_4096(setup_decode_corncobs(zeros(4096)))]
#[bench::nonzero_0(setup_decode_corncobs(nonzero(0)))]
#[bench::nonzero_1(setup_decode_corncobs(nonzero(1)))]
#[bench::nonzero_10(setup_decode_corncobs(nonzero(10)))]
#[bench::nonzero_64(setup_decode_corncobs(nonzero(64)))]
#[bench::nonzero_254(setup_decode_corncobs(nonzero(254)))]
#[bench::nonzero_255(setup_decode_corncobs(nonzero(255)))]
#[bench::nonzero_256(setup_decode_corncobs(nonzero(256)))]
#[bench::nonzero_1024(setup_decode_corncobs(nonzero(1024)))]
#[bench::nonzero_4096(setup_decode_corncobs(nonzero(4096)))]
#[bench::mixed_0(setup_decode_corncobs(mixed(0)))]
#[bench::mixed_1(setup_decode_corncobs(mixed(1)))]
#[bench::mixed_10(setup_decode_corncobs(mixed(10)))]
#[bench::mixed_64(setup_decode_corncobs(mixed(64)))]
#[bench::mixed_254(setup_decode_corncobs(mixed(254)))]
#[bench::mixed_255(setup_decode_corncobs(mixed(255)))]
#[bench::mixed_256(setup_decode_corncobs(mixed(256)))]
#[bench::mixed_1024(setup_decode_corncobs(mixed(1024)))]
#[bench::mixed_4096(setup_decode_corncobs(mixed(4096)))]
fn decode_corncobs((enc, mut buf): (Vec<u8>, Vec<u8>)) {
    let _ = black_box(corncobs::decode_buf(black_box(&enc), &mut buf));
}

#[library_benchmark]
#[bench::zeros_0(setup_decode_cobs(zeros(0)))]
#[bench::zeros_1(setup_decode_cobs(zeros(1)))]
#[bench::zeros_10(setup_decode_cobs(zeros(10)))]
#[bench::zeros_64(setup_decode_cobs(zeros(64)))]
#[bench::zeros_254(setup_decode_cobs(zeros(254)))]
#[bench::zeros_255(setup_decode_cobs(zeros(255)))]
#[bench::zeros_256(setup_decode_cobs(zeros(256)))]
#[bench::zeros_1024(setup_decode_cobs(zeros(1024)))]
#[bench::zeros_4096(setup_decode_cobs(zeros(4096)))]
#[bench::nonzero_0(setup_decode_cobs(nonzero(0)))]
#[bench::nonzero_1(setup_decode_cobs(nonzero(1)))]
#[bench::nonzero_10(setup_decode_cobs(nonzero(10)))]
#[bench::nonzero_64(setup_decode_cobs(nonzero(64)))]
#[bench::nonzero_254(setup_decode_cobs(nonzero(254)))]
#[bench::nonzero_255(setup_decode_cobs(nonzero(255)))]
#[bench::nonzero_256(setup_decode_cobs(nonzero(256)))]
#[bench::nonzero_1024(setup_decode_cobs(nonzero(1024)))]
#[bench::nonzero_4096(setup_decode_cobs(nonzero(4096)))]
#[bench::mixed_0(setup_decode_cobs(mixed(0)))]
#[bench::mixed_1(setup_decode_cobs(mixed(1)))]
#[bench::mixed_10(setup_decode_cobs(mixed(10)))]
#[bench::mixed_64(setup_decode_cobs(mixed(64)))]
#[bench::mixed_254(setup_decode_cobs(mixed(254)))]
#[bench::mixed_255(setup_decode_cobs(mixed(255)))]
#[bench::mixed_256(setup_decode_cobs(mixed(256)))]
#[bench::mixed_1024(setup_decode_cobs(mixed(1024)))]
#[bench::mixed_4096(setup_decode_cobs(mixed(4096)))]
fn decode_cobs((enc, mut buf): (Vec<u8>, Vec<u8>)) {
    black_box(
        cobs::decode(black_box(&enc), &mut buf)
            .map(|r| r.parsed_size())
            .unwrap_or(0),
    );
}

// ── Groups ─────────────────────────────────────────────────────────

library_benchmark_group!(
    name = encode;
    benchmarks = encode_ucobs, encode_corncobs, encode_cobs
);

library_benchmark_group!(
    name = decode;
    benchmarks = decode_ucobs, decode_corncobs, decode_cobs
);

main!(library_benchmark_groups = encode, decode);