#[macro_use]
extern crate criterion;
extern crate rustt as tt;
use criterion::black_box;
use criterion::Criterion;
use serde::{Deserialize, Serialize};
use tt::ttv3::Key;
use tt::ttv3::Value;
criterion_main!(
worst_case_serde_json_static,
worst_case_serde_static_rwv3,
worst_case_serde_staticv3,
worst_case_serdev3,
u64_serdev3,
);
#[derive(Serialize, Deserialize)]
struct SubWorstCase {
#[serde(rename = "more")]
more: String,
}
#[derive(Serialize, Deserialize)]
struct WorstCase {
#[serde(rename = "Da5ta")]
data: String,
#[serde(rename = "Data2")]
subdata: SubWorstCase,
#[serde(rename = "Data4")]
sublist: Vec<String>,
#[serde(rename = "1", with = "serde_bytes")]
subbytes: Vec<u8>,
#[serde(rename = "2")]
float: f64,
#[serde(rename = "3")]
int: i64,
#[serde(rename = "4")]
bool: bool,
}
criterion_group! {
name = worst_case_serde_json_static;
config = Criterion::default().confidence_level(0.01).measurement_time(std::time::Duration::new(20, 0));
targets = bench_enc_dec_worst_case_serde_json_static ,
}
fn bench_enc_dec_worst_case_serde_json_static(c: &mut Criterion) {
let w = WorstCase {
data: String::from("n0thing"),
subdata: SubWorstCase {
more: String::from("d5ata89"),
},
sublist: vec![String::from("hey"), String::from("jude")],
subbytes: vec![b'h', b'i'],
float: 0.64,
int: 99,
bool: true,
};
c.bench_function("enc_dec_worst_case_serde_json_static", |b| {
b.iter(|| {
let data = serde_json::to_string(&w).unwrap();
let m: WorstCase = serde_json::from_str(&data).unwrap();
black_box(m);
})
});
c.bench_function("enc_worst_case_serde_json_static", |b| {
b.iter(|| {
black_box(serde_json::to_string(&w).unwrap());
})
});
c.bench_function("dec_worst_case_serde_json_static", |b| {
let data = serde_json::to_string(&w).unwrap();
b.iter(|| {
let m: WorstCase = serde_json::from_str(&data).unwrap();
black_box(m);
})
});
}
criterion_group! {
name = worst_case_serde_static_rwv3;
config = Criterion::default().confidence_level(0.01).measurement_time(std::time::Duration::new(20, 0));
targets = bench_enc_dec_worst_case_serde_static_rwv3 ,
}
fn bench_enc_dec_worst_case_serde_static_rwv3(c: &mut Criterion) {
let w = WorstCase {
data: String::from("n0thing"),
subdata: SubWorstCase {
more: String::from("d5ata89"),
},
sublist: vec![String::from("hey"), String::from("jude")],
subbytes: vec![b'h', b'i'],
float: 0.64,
int: 99,
bool: true,
};
c.bench_function("enc_dec_worst_case_serde_static_rwv3", |b| {
b.iter(|| {
let data = tt::to_vec(&w).unwrap();
let m: WorstCase = tt::from_reader(&data[..]).unwrap();
black_box(m);
})
});
c.bench_function("enc_worst_case_serde_static_rwv3", |b| {
b.iter(|| {
black_box(tt::to_vec(&w)).unwrap();
});
});
c.bench_function("dec_worst_case_serde_static_rwv3", |b| {
let data = tt::to_vec(&w).unwrap();
b.iter(|| {
let m: WorstCase = tt::from_reader(&data[..]).unwrap();
black_box(m);
})
});
}
criterion_group! {
name = worst_case_serde_staticv3;
config = Criterion::default().confidence_level(0.01).measurement_time(std::time::Duration::new(20, 0));
targets = bench_enc_dec_worst_case_serde_staticv3 ,
}
fn bench_enc_dec_worst_case_serde_staticv3(c: &mut Criterion) {
let w = WorstCase {
data: String::from("n0thing"),
subdata: SubWorstCase {
more: String::from("d5ata89"),
},
sublist: vec![String::from("hey"), String::from("jude")],
subbytes: vec![b'h', b'i'],
float: 0.64,
int: 99,
bool: true,
};
c.bench_function("enc_dec_worst_case_serde_staticv3", |b| {
b.iter(|| {
let data = tt::to_vec(&w).unwrap();
let m: WorstCase = tt::from_bytes(&data).unwrap();
black_box(m);
})
});
c.bench_function("enc_worst_case_serde_staticv3", |b| {
b.iter(|| {
black_box(tt::to_vec(&w).unwrap());
});
});
c.bench_function("dec_worst_case_serde_staticv3", |b| {
let data = tt::to_vec(&w).unwrap();
b.iter(|| {
let m: WorstCase = tt::from_bytes(&data).unwrap();
black_box(m);
})
});
}
criterion_group! {
name = worst_case_serdev3;
config = Criterion::default().confidence_level(0.01).measurement_time(std::time::Duration::new(20, 0));
targets = bench_enc_dec_worst_case_serdev3,
}
fn bench_enc_dec_worst_case_serdev3(c: &mut Criterion) {
let mut map: std::collections::HashMap<&str, Value> = std::collections::HashMap::new();
map.insert(&"Da5ta", Value::String("n0thing".to_string()));
let mut submap: std::collections::HashMap<Key, Value> = std::collections::HashMap::new();
submap.insert(
Key::String("more".to_string()),
Value::String("d5ata89".to_string()),
);
map.insert(&"Data2", Value::Map(submap));
let vec: Vec<Value> = vec![
Value::String("hey".to_string()),
Value::String("jude".to_string()),
];
map.insert(&"Data4", Value::Vec(vec));
let vec2 = vec![1, 2];
map.insert(&"1", Value::Bytes(vec2));
map.insert(&"2", Value::F64(0.64 as f64));
map.insert(&"3", Value::I64(99 as i64));
map.insert(&"4", Value::Bool(true));
c.bench_function("enc_dec_worst_case_serdev3", |b| {
b.iter(|| {
let data = tt::to_vec(&map).unwrap();
let m: std::collections::HashMap<&str, Value> = tt::from_bytes(&data).unwrap();
black_box(m);
})
});
c.bench_function("enc_worst_case_serdev3", |b| {
b.iter(|| {
black_box(tt::to_vec(&map).unwrap());
});
});
c.bench_function("dec_worst_case_serdev3", |b| {
let data = tt::to_vec(&map).unwrap();
b.iter(|| {
let m: std::collections::HashMap<&str, Value> = tt::from_bytes(&data).unwrap();
black_box(m);
})
});
}
criterion_group! {
name = u64_serdev3;
config = Criterion::default().confidence_level(0.01).measurement_time(std::time::Duration::new(60, 0));
targets = bench_enc_dec_u64_serdev3,
}
fn bench_enc_dec_u64_serdev3(c: &mut Criterion) {
let i: u64 = 46372;
c.bench_function("enc_dec_u64_serdev3", |b| {
b.iter(|| {
let data = tt::to_vec(&i).unwrap();
let m: u64 = tt::from_bytes(&data).unwrap();
black_box(m);
})
});
c.bench_function("enc_u64_serdev3", |b| {
b.iter(|| {
black_box(tt::to_vec(&i).unwrap());
});
});
c.bench_function("dec_u64_serdev3", |b| {
let data = tt::to_vec(&i).unwrap();
b.iter(|| {
let m: u64 = tt::from_bytes(&data).unwrap();
black_box(m);
})
});
}