zerompk 0.7.1

A zero-copy, zero-dependency, no_std-compatible, extremely fast MessagePack serializer for Rust.
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

#![feature(test)]

extern crate test;

use serde_json::{Value as JsonValue, json};
use zerompk::Value;

const N: usize = 1_000;

fn value() -> JsonValue {
    json!({
        "name": "zerompk",
        "active": true,
        "version": 6,
        "ratio": 1.25,
        "tags": ["messagepack", "rust", "zero-copy", "no-std"],
        "authors": [
            {"name": "Alice", "commits": 127, "active": true},
            {"name": "Bob", "commits": 63, "active": false},
            {"name": "Carol", "commits": 255, "active": true}
        ],
        "metrics": {
            "downloads": [1, 127, 128, 255, 256, 65535, 65536],
            "latencies": [0.25, 1.5, 12.75, 100.125],
            "nullable": null
        }
    })
}

fn data() -> Vec<u8> {
    rmp_serde::to_vec(&value()).unwrap()
}

#[bench]
fn deserialize_value_zerompk(b: &mut test::Bencher) {
    let data = test::black_box(data());
    b.bytes = (data.len() * N) as u64;
    b.iter(|| {
        for _ in 0..N {
            test::black_box(zerompk::from_msgpack::<Value>(&data).unwrap());
        }
    });
}

#[bench]
fn deserialize_value_rmpv(b: &mut test::Bencher) {
    let data = test::black_box(data());
    b.bytes = (data.len() * N) as u64;
    b.iter(|| {
        for _ in 0..N {
            test::black_box(rmpv::decode::read_value(&mut &data[..]).unwrap());
        }
    });
}

#[bench]
fn deserialize_value_msgpacker(b: &mut test::Bencher) {
    let data = test::black_box(data());
    b.bytes = (data.len() * N) as u64;
    b.iter(|| {
        for _ in 0..N {
            test::black_box(msgpacker::serde::from_slice::<JsonValue>(&data).unwrap());
        }
    });
}

#[bench]
fn serialize_value_zerompk(b: &mut test::Bencher) {
    let data = data();
    let value: Value = zerompk::from_msgpack(&data).unwrap();
    assert_eq!(zerompk::to_msgpack_vec(&value).unwrap(), data);
    b.bytes = (data.len() * N) as u64;
    b.iter(|| {
        for _ in 0..N {
            test::black_box(zerompk::to_msgpack_vec(&value).unwrap());
        }
    });
}

#[bench]
fn serialize_value_rmpv(b: &mut test::Bencher) {
    let data = data();
    let value = rmpv::decode::read_value(&mut &data[..]).unwrap();
    let mut buf = Vec::with_capacity(data.len());
    rmpv::encode::write_value(&mut buf, &value).unwrap();
    assert_eq!(buf, data);
    b.bytes = (data.len() * N) as u64;
    b.iter(|| {
        for _ in 0..N {
            let mut buf = Vec::with_capacity(data.len());
            rmpv::encode::write_value(&mut buf, &value).unwrap();
            test::black_box(buf);
        }
    });
}

#[bench]
fn serialize_value_msgpacker(b: &mut test::Bencher) {
    let value = value();
    let data = data();
    assert_eq!(msgpacker::serde::to_vec(&value), data);
    b.bytes = (data.len() * N) as u64;
    b.iter(|| {
        for _ in 0..N {
            test::black_box(msgpacker::serde::to_vec(&value));
        }
    });
}