corncobs 0.1.4

COBS encode/decode for Rust no_std targets
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

use criterion::{criterion_group, criterion_main, Criterion};
use std::hint::black_box;

const RANDOM_1024: [u8; 1024] = *include_bytes!("random-1k.bin");
const ZERO_1024: [u8; 1024] = *include_bytes!("zero-1k.bin");
const FF_1024: [u8; 1024] = *include_bytes!("ff-1k.bin");

pub fn criterion_benchmark(c: &mut Criterion) {
    let mut out = [0; corncobs::max_encoded_len(RANDOM_1024.len())];
    c.bench_function("encode_buf random 1024", move |b| b.iter(|| {
        corncobs::encode_buf(black_box(&RANDOM_1024), &mut out);
    }));

    let mut out = [0; corncobs::max_encoded_len(RANDOM_1024.len())];
    c.bench_function("encode_iter random 1024", move |b| b.iter(|| {
        for (b, o) in corncobs::encode_iter(black_box(&RANDOM_1024)).zip(&mut out) {
            *o = b;
        }
    }));


    let mut random_enc_1024 = [0; corncobs::max_encoded_len(RANDOM_1024.len())];
    let n = corncobs::encode_buf(&RANDOM_1024, &mut random_enc_1024);
    let random_enc_1024 = &random_enc_1024[..n];

    let mut out = [0; RANDOM_1024.len()];
    c.bench_function("decode_buf random 1024", move |b| b.iter(|| {
        corncobs::decode_buf(black_box(random_enc_1024), &mut out).unwrap();
    }));
    c.bench_function("decode_in_place random 1024", move |b| b.iter_batched(
        || random_enc_1024.to_vec(),
        |mut data| corncobs::decode_in_place(&mut data).unwrap(),
        criterion::BatchSize::SmallInput,
    ));


    let mut out = [0; corncobs::max_encoded_len(ZERO_1024.len())];
    c.bench_function("encode_buf zero 1024", move |b| b.iter(|| {
        corncobs::encode_buf(black_box(&ZERO_1024), &mut out);
    }));


    let mut zero_enc_1024 = [0; corncobs::max_encoded_len(ZERO_1024.len())];
    let n = corncobs::encode_buf(&ZERO_1024, &mut zero_enc_1024);
    let zero_enc_1024 = &zero_enc_1024[..n];

    let mut out = [0; ZERO_1024.len()];
    c.bench_function("decode_buf zero 1024", move |b| b.iter(|| {
        corncobs::decode_buf(black_box(zero_enc_1024), &mut out).unwrap();
    }));
    c.bench_function("decode_in_place zero 1024", move |b| b.iter_batched(
        || zero_enc_1024.to_vec(),
        |mut data| corncobs::decode_in_place(&mut data).unwrap(),
        criterion::BatchSize::SmallInput,
    ));


    let mut out = [0; corncobs::max_encoded_len(FF_1024.len())];
    c.bench_function("encode_buf ff 1024", move |b| b.iter(|| {
        corncobs::encode_buf(black_box(&FF_1024), &mut out);
    }));

    let mut ff_enc_1024 = [0; corncobs::max_encoded_len(FF_1024.len())];
    let n = corncobs::encode_buf(&FF_1024, &mut ff_enc_1024);
    let ff_enc_1024 = &ff_enc_1024[..n];

    let mut out = [0; FF_1024.len()];
    c.bench_function("decode_buf ff 1024", move |b| b.iter(|| {
        corncobs::decode_buf(black_box(ff_enc_1024), &mut out).unwrap();
    }));
    c.bench_function("decode_in_place ff 1024", move |b| b.iter_batched(
        || ff_enc_1024.to_vec(),
        |mut data| corncobs::decode_in_place(&mut data).unwrap(),
        criterion::BatchSize::SmallInput,
    ));
}

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