#[macro_use]
extern crate criterion;
#[macro_use]
extern crate serde_derive;
use criterion::Criterion;
use handlebars::{to_json, Context, Handlebars, Template};
use serde_json::value::Value as Json;
use std::collections::BTreeMap;
#[cfg(unix)]
use criterion::profiler::Profiler;
#[cfg(unix)]
use pprof::protos::Message;
#[cfg(unix)]
use pprof::ProfilerGuard;
#[cfg(unix)]
use std::fs::{create_dir_all, File};
#[cfg(unix)]
use std::io::Write;
#[cfg(unix)]
use std::path::Path;
#[cfg(unix)]
#[derive(Default)]
struct CpuProfiler<'a> {
guard: Option<ProfilerGuard<'a>>,
}
#[cfg(unix)]
impl<'a> Profiler for CpuProfiler<'a> {
fn start_profiling(&mut self, _benchmark_id: &str, benchmark_dir: &Path) {
create_dir_all(&benchmark_dir).unwrap();
let guard = ProfilerGuard::new(100).unwrap();
self.guard = Some(guard);
}
fn stop_profiling(&mut self, benchmark_id: &str, benchmark_dir: &Path) {
if let Ok(ref report) = self.guard.as_ref().unwrap().report().build() {
let fg_file_name = benchmark_dir.join(format!("{}.svg", benchmark_id));
let fg_file = File::create(fg_file_name).unwrap();
report.flamegraph(fg_file).unwrap();
let pb_file_name = benchmark_dir.join(format!("{}.pb", benchmark_id));
let mut pb_file = File::create(pb_file_name).unwrap();
let profile = report.pprof().unwrap();
let mut content = Vec::new();
profile.encode(&mut content).unwrap();
pb_file.write_all(&content).unwrap();
};
self.guard = None;
}
}
#[cfg(unix)]
fn profiled() -> Criterion {
Criterion::default().with_profiler(CpuProfiler::default())
}
#[derive(Serialize)]
struct DataWrapper {
v: String,
}
#[derive(Serialize)]
struct RowWrapper {
real: Vec<DataWrapper>,
dummy: Vec<DataWrapper>,
}
#[derive(Serialize)]
struct NestedRowWrapper {
parent: Vec<Vec<DataWrapper>>,
}
static SOURCE: &'static str = "<html>
<head>
<title>{{year}}</title>
</head>
<body>
<h1>CSL {{year}}</h1>
<ul>
{{#each teams}}
<li class=\"{{#if @first}}champion{{/if}}\">
<b>{{name}}</b>: {{score}}
</li>
{{/each}}
</ul>
</body>
</html>";
fn make_data() -> BTreeMap<String, Json> {
let mut data = BTreeMap::new();
data.insert("year".to_string(), to_json("2015"));
let mut teams = Vec::new();
for v in vec![
("Jiangsu", 43u16),
("Beijing", 27u16),
("Guangzhou", 22u16),
("Shandong", 12u16),
]
.iter()
{
let (name, score) = *v;
let mut t = BTreeMap::new();
t.insert("name".to_string(), to_json(name));
t.insert("score".to_string(), to_json(score));
teams.push(t)
}
data.insert("teams".to_string(), to_json(&teams));
data
}
fn parse_template(c: &mut Criterion) {
c.bench_function("parse_template", move |b| {
b.iter(|| Template::compile(SOURCE).ok().unwrap())
});
}
fn render_template(c: &mut Criterion) {
let mut handlebars = Handlebars::new();
handlebars
.register_template_string("table", SOURCE)
.ok()
.expect("Invalid template format");
let ctx = Context::wraps(make_data()).unwrap();
c.bench_function("render_template", move |b| {
b.iter(|| handlebars.render_with_context("table", &ctx).ok().unwrap())
});
}
fn large_loop_helper(c: &mut Criterion) {
let mut handlebars = Handlebars::new();
handlebars
.register_template_string("test", "BEFORE\n{{#each real}}{{this.v}}{{/each}}AFTER")
.ok()
.expect("Invalid template format");
let real: Vec<DataWrapper> = (1..1000)
.map(|i| DataWrapper {
v: format!("n={}", i),
})
.collect();
let dummy: Vec<DataWrapper> = (1..1000)
.map(|i| DataWrapper {
v: format!("n={}", i),
})
.collect();
let rows = RowWrapper { real, dummy };
let ctx = Context::wraps(&rows).unwrap();
c.bench_function("large_loop_helper", move |b| {
b.iter(|| handlebars.render_with_context("test", &ctx).ok().unwrap())
});
}
fn large_loop_helper_with_context_creation(c: &mut Criterion) {
let mut handlebars = Handlebars::new();
handlebars
.register_template_string("test", "BEFORE\n{{#each real}}{{this.v}}{{/each}}AFTER")
.ok()
.expect("Invalid template format");
let real: Vec<DataWrapper> = (1..1000)
.map(|i| DataWrapper {
v: format!("n={}", i),
})
.collect();
let dummy: Vec<DataWrapper> = (1..1000)
.map(|i| DataWrapper {
v: format!("n={}", i),
})
.collect();
let rows = RowWrapper { real, dummy };
c.bench_function("large_loop_helper_with_context_creation", move |b| {
b.iter(|| handlebars.render("test", &rows).ok().unwrap())
});
}
fn large_nested_loop(c: &mut Criterion) {
let mut handlebars = Handlebars::new();
handlebars
.register_template_string(
"test",
"BEFORE\n{{#each parent as |child|}}{{#each child}}{{this.v}}{{/each}}{{/each}}AFTER",
)
.ok()
.expect("Invalid template format");
let parent: Vec<Vec<DataWrapper>> = (1..100)
.map(|_| {
(1..10)
.map(|v| DataWrapper {
v: format!("v={}", v),
})
.collect()
})
.collect();
let rows = NestedRowWrapper { parent };
let ctx = Context::wraps(&rows).unwrap();
c.bench_function("large_nested_loop", move |b| {
b.iter(|| handlebars.render_with_context("test", &ctx).ok().unwrap())
});
}
#[cfg(unix)]
criterion_group!(
name = benches;
config = profiled();
targets = parse_template, render_template, large_loop_helper, large_loop_helper_with_context_creation,
large_nested_loop
);
#[cfg(not(unix))]
criterion_group!(
benches,
parse_template,
render_template,
large_loop_helper,
large_loop_helper_with_context_creation,
large_nested_loop
);
criterion_main!(benches);