simd-json 0.17.0

High performance JSON parser based on a port of simdjson
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

#[macro_use]
extern crate criterion;

use core::time::Duration;

#[cfg(feature = "jemallocator")]
#[global_allocator]
static ALLOC: jemallocator::Jemalloc = jemallocator::Jemalloc;

#[cfg(feature = "bench-serde")]
use serde_json;

use criterion::{BatchSize, Criterion, Throughput, criterion_group};
use simd_json::Buffers;

use std::fs::File;
use std::io::Read;

fn to_borrowed_value(data: &mut [u8]) {
    simd_json::to_borrowed_value(data).unwrap();
}

fn to_borrowed_value_with_buffers(data: &mut [u8], buffers: &mut Buffers) {
    simd_json::to_borrowed_value_with_buffers(data, buffers).unwrap();
}

fn to_owned_value(data: &mut [u8]) {
    simd_json::to_owned_value(data).unwrap();
}

#[cfg(feature = "bench-serde")]
fn serde_from_slice(data: &[u8]) {
    let _: serde_json::Value = serde_json::from_slice(data).unwrap();
}

macro_rules! bench_file {
    ($name:ident) => {
        fn $name(c: &mut Criterion) {
            let core_ids = core_affinity::get_core_ids().unwrap();
            core_affinity::set_for_current(core_ids[0]);

            let mut vec = Vec::new();
            File::open(concat!("data/", stringify!($name), ".json"))
                .unwrap()
                .read_to_end(&mut vec)
                .unwrap();

            let mut group = c.benchmark_group(stringify!($name));
            group.throughput(Throughput::Bytes(vec.len() as u64));
            group
                .warm_up_time(Duration::from_secs(1))
                .measurement_time(Duration::from_secs(20));

            let mut buffers = Buffers::default();

            group.bench_with_input("simd_json::to_borrowed_value", &vec, |b, data| {
                b.iter_batched(
                    || data.clone(),
                    |mut bytes| to_borrowed_value(&mut bytes),
                    BatchSize::SmallInput,
                )
            });

            group.bench_with_input(
                "simd_json::to_borrowed_value_with_buffers",
                &vec,
                |b, data| {
                    b.iter_batched(
                        || data.clone(),
                        |mut bytes| to_borrowed_value_with_buffers(&mut bytes, &mut buffers),
                        BatchSize::SmallInput,
                    )
                },
            );

            group.bench_with_input("simd_json::to_owned_value", &vec, |b, data| {
                b.iter_batched(
                    || data.clone(),
                    |mut bytes| to_owned_value(&mut bytes),
                    BatchSize::SmallInput,
                )
            });

            #[cfg(feature = "bench-serde")]
            group.bench_with_input("serde_json::from_slice", &vec, |b, data| {
                b.iter_batched(
                    || data,
                    |bytes| serde_from_slice(&bytes),
                    BatchSize::SmallInput,
                )
            });
        }
    };
}

bench_file!(apache_builds);
bench_file!(event_stacktrace_10kb);
bench_file!(github_events);
bench_file!(canada);
bench_file!(citm_catalog);
bench_file!(log);
bench_file!(twitter);

criterion_group!(
    benches,
    apache_builds,
    event_stacktrace_10kb,
    github_events,
    canada,
    citm_catalog,
    log,
    twitter
);
criterion_main!(benches);