anpp 2.0.0

A Rust implementation of the Advanced Navigation Packet 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

extern crate anpp;
#[macro_use]
extern crate criterion;

use anpp::{utils, Decoder, Packet};
use criterion::{Criterion, ParameterizedBenchmark, Throughput};

fn sizes() -> Vec<u32> { vec![1, 32, 127, 255] }

fn random_packet(size: u32) -> Packet {
    let bytes: Vec<u8> = (0..size as u8).collect();
    Packet::with_data(42, &bytes).unwrap()
}

fn decoder_with_random_packet(size: u32) -> Decoder {
    let pkt = random_packet(size);
    let mut buffer = vec![0; pkt.total_length()];
    pkt.write_to_buffer(&mut buffer).unwrap();

    let mut decoder = Decoder::new();
    decoder.push_data(&buffer).unwrap();
    decoder
}

fn generate_header(c: &mut Criterion) {
    c.bench(
        "anpp",
        ParameterizedBenchmark::new(
            "generate-header",
            |b, &len| {
                let pkt = random_packet(len);
                let mut buffer = vec![0; pkt.total_length()];

                b.iter(|| pkt.write_to_buffer(&mut buffer).unwrap())
            },
            sizes(),
        )
        .throughput(|&len| Throughput::Bytes(len)),
    );
}

fn decode_packet(c: &mut Criterion) {
    c.bench(
        "anpp",
        ParameterizedBenchmark::new(
            "decode-packet",
            |b, &len| {
                let dec = decoder_with_random_packet(len);

                b.iter(|| dec.clone().decode().unwrap())
            },
            sizes(),
        )
        .throughput(|&len| Throughput::Bytes(len)),
    );
}

fn utility_functions(c: &mut Criterion) {
    let inputs = vec![0, 10, 100, 1000];

    c.bench(
        "utils",
        ParameterizedBenchmark::new(
            "crc16",
            |b, &len| {
                let data: Vec<u8> = (0..len as u8).collect();
                b.iter(|| utils::calculate_crc16(&data))
            },
            inputs,
        )
        .throughput(|&len| Throughput::Bytes(len)),
    );
}

fn crc_vs_header_gen(c: &mut Criterion) {
    c.bench(
        "crc-vs-header-gen",
        ParameterizedBenchmark::new(
            "generate-header",
            |b, &len| {
                let pkt = random_packet(len);
                let mut buffer = vec![0; pkt.total_length()];
                b.iter(|| pkt.write_to_buffer(&mut buffer).unwrap());
            },
            sizes(),
        )
        .with_function("crc", |b, &len| {
            let data: Vec<u8> = (0..len as u8).collect();
            b.iter(|| utils::calculate_crc16(&data))
        })
        .throughput(|&len| Throughput::Bytes(len)),
    );
}

criterion_group! { benches, generate_header, decode_packet, utility_functions, crc_vs_header_gen }

criterion_main!(benches);