tls_codec 0.4.2

A pure Rust implementation of the TLS (de)serialization
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

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

fn vector(c: &mut Criterion) {
    use tls_codec::*;
    c.bench_function("TLS Serialize Vector", |b| {
        b.iter_batched(
            || TlsVecU32::from(vec![77u8; 65535]),
            |long_vector| {
                let _serialized_long_vec = long_vector.tls_serialize_detached().unwrap();
            },
            BatchSize::SmallInput,
        )
    });
    c.bench_function("TLS Deserialize Vector", |b| {
        b.iter_batched(
            || {
                let long_vector = vec![77u8; 65535];
                TlsSliceU32(&long_vector).tls_serialize_detached().unwrap()
            },
            |serialized_long_vec| {
                let _deserialized_long_vec =
                    TlsVecU32::<u8>::tls_deserialize(&mut serialized_long_vec.as_slice()).unwrap();
            },
            BatchSize::SmallInput,
        )
    });
}

fn byte_vector(c: &mut Criterion) {
    use tls_codec::*;
    c.bench_function("TLS Serialize Byte Vector", |b| {
        b.iter_batched(
            || TlsByteVecU32::from(vec![77u8; 65535]),
            |long_vector| {
                let _serialized_long_vec = long_vector.tls_serialize_detached().unwrap();
            },
            BatchSize::SmallInput,
        )
    });
    c.bench_function("TLS Deserialize Byte Vector", |b| {
        b.iter_batched(
            || {
                let long_vector = vec![77u8; 65535];
                TlsByteSliceU32(&long_vector)
                    .tls_serialize_detached()
                    .unwrap()
            },
            |serialized_long_vec| {
                let _deserialized_long_vec =
                    TlsVecU32::<u8>::tls_deserialize(&mut serialized_long_vec.as_slice()).unwrap();
            },
            BatchSize::SmallInput,
        )
    });
}

fn byte_slice(c: &mut Criterion) {
    use tls_codec::*;
    c.bench_function("TLS Serialize Byte Slice", |b| {
        b.iter_batched(
            || vec![77u8; 65535],
            |long_vector| {
                let _serialized_long_vec = TlsByteSliceU32(&long_vector)
                    .tls_serialize_detached()
                    .unwrap();
            },
            BatchSize::SmallInput,
        )
    });
}

fn slice(c: &mut Criterion) {
    use tls_codec::*;
    c.bench_function("TLS Serialize Slice", |b| {
        b.iter_batched(
            || vec![77u8; 65535],
            |long_vector| {
                let _serialized_long_vec =
                    TlsSliceU32(&long_vector).tls_serialize_detached().unwrap();
            },
            BatchSize::SmallInput,
        )
    });
}
fn benchmark(c: &mut Criterion) {
    vector(c);
    slice(c);
    byte_vector(c);
    byte_slice(c);
}

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