phoros 0.1.2

Zero-allocation ring buffer with XOR delta encoding and state rollback
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

use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};

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

    for (name, size) in [
        ("doc_state", 152),
        ("small_config", 32),
        ("large_state", 1024),
    ] {
        group.bench_with_input(BenchmarkId::new("zero_delta", name), &size, |b, &size| {
            let delta = vec![0u8; size];
            let mut output = vec![0u8; 10 * size.div_ceil(8) + 1];
            b.iter(|| phoros::codec::byte_masked_encode(&delta, &mut output).unwrap());
        });

        group.bench_with_input(BenchmarkId::new("sparse_10pct", name), &size, |b, &size| {
            let mut delta = vec![0u8; size];
            for i in (0..size).step_by(10) {
                delta[i] = 0xAB;
            }
            let mut output = vec![0u8; 10 * size.div_ceil(8) + 1];
            b.iter(|| phoros::codec::byte_masked_encode(&delta, &mut output).unwrap());
        });

        group.bench_with_input(BenchmarkId::new("full_delta", name), &size, |b, &size| {
            let delta = vec![0xAB; size];
            let mut output = vec![0u8; 10 * size.div_ceil(8) + 1];
            b.iter(|| phoros::codec::byte_masked_encode(&delta, &mut output).unwrap());
        });
    }

    group.finish();
}

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

    for (name, size) in [
        ("doc_state", 152),
        ("small_config", 32),
        ("large_state", 1024),
    ] {
        let mut delta = vec![0u8; size];
        for i in (0..size).step_by(10) {
            delta[i] = 0xAB;
        }
        let mut encoded = vec![0u8; 10 * size.div_ceil(8) + 1];
        let len = phoros::codec::byte_masked_encode(&delta, &mut encoded).unwrap();
        encoded.truncate(len);

        group.bench_with_input(
            BenchmarkId::new("sparse_10pct", name),
            &encoded,
            |b, enc| {
                b.iter(|| {
                    let mut output = vec![0u8; size];
                    phoros::codec::byte_masked_decode(enc, &mut output).unwrap();
                });
            },
        );
    }

    group.finish();
}

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

    for (name, size) in [
        ("doc_state", 152),
        ("small_config", 32),
        ("large_state", 1024),
    ] {
        let data = vec![0x42u8; size];
        group.bench_with_input(BenchmarkId::new("compute", name), &data, |b, d| {
            b.iter(|| phoros::codec::crc16(d));
        });
    }

    group.finish();
}

criterion_group!(benches, bench_encode, bench_decode, bench_crc16);
criterion_main!(benches);