mutnet 0.7.0

Unsafe-free and allocation-free, no-std network protocol parsing and in-place manipulation library.
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
114
115
116
117
118
119
120
121
122

use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput};

use mutnet::addresses::mac::MacAddress;
use mutnet::arp::{ArpMethods, ParseArpError};

include!("utils.rs");

#[inline(always)]
fn mutnet_new(
    bytes: &mut [u8],
) -> Result<DataBuffer<&mut [u8], Arp<NoPreviousHeader>>, ParseArpError> {
    DataBuffer::<_, Arp<NoPreviousHeader>>::parse_arp_alone(bytes, 0)
}

#[inline(always)]
fn mutnet_get_functions_inlined(
    data_buffer: &impl ArpMethods,
) -> (
    u16,
    u16,
    u16,
    u8,
    u8,
    MacAddress,
    Ipv4Addr,
    MacAddress,
    Ipv4Addr,
) {
    (
        data_buffer.arp_hardware_type(),
        data_buffer.arp_protocol_type(),
        data_buffer.arp_operation_code(),
        data_buffer.arp_hardware_address_length(),
        data_buffer.arp_protocol_address_length(),
        data_buffer.arp_sender_hardware_address(),
        data_buffer.arp_sender_protocol_address(),
        data_buffer.arp_target_hardware_address(),
        data_buffer.arp_target_protocol_address(),
    )
}

#[inline(never)]
fn mutnet_get_functions_not_inlined(
    data_buffer: &impl ArpMethods,
) -> (
    u16,
    u16,
    u16,
    u8,
    u8,
    MacAddress,
    Ipv4Addr,
    MacAddress,
    Ipv4Addr,
) {
    (
        data_buffer.arp_hardware_type(),
        data_buffer.arp_protocol_type(),
        data_buffer.arp_operation_code(),
        data_buffer.arp_hardware_address_length(),
        data_buffer.arp_protocol_address_length(),
        data_buffer.arp_sender_hardware_address(),
        data_buffer.arp_sender_protocol_address(),
        data_buffer.arp_target_hardware_address(),
        data_buffer.arp_target_protocol_address(),
    )
}

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

    group.throughput(Throughput::Bytes(random_valid_arp().len() as u64));

    group.bench_function("mutnet: new", |b| {
        b.iter_batched_ref(
            random_valid_arp,
            |data| {
                let mut result = &mut mutnet_new(std::hint::black_box(data));
                std::hint::black_box(&mut result);
            },
            BatchSize::SmallInput,
        );
    });

    group.bench_function("mutnet: new + get functions inlined", |b| {
        b.iter_batched_ref(
            random_valid_arp,
            |data| {
                let buffer = DataBuffer::<_, Arp<NoPreviousHeader>>::parse_arp_alone(
                    std::hint::black_box(data),
                    0,
                )
                .unwrap();
                let mut result = &mut mutnet_get_functions_inlined(&buffer);
                std::hint::black_box(&mut result);
            },
            BatchSize::SmallInput,
        );
    });

    group.bench_function("mutnet: new + get functions not inlined", |b| {
        b.iter_batched_ref(
            random_valid_arp,
            |data| {
                let buffer = DataBuffer::<_, Arp<NoPreviousHeader>>::parse_arp_alone(
                    std::hint::black_box(data),
                    0,
                )
                .unwrap();
                let mut result = &mut mutnet_get_functions_not_inlined(&buffer);
                std::hint::black_box(&mut result);
            },
            BatchSize::SmallInput,
        );
    });

    group.finish();
}

criterion_group!(benches, arp);

criterion_main!(benches);