kip 0.1.1

Pure thread-safe engineering expression evaluator for US imperial units
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

//! Parse and eval throughput (M8 criterion suite).

use std::sync::Arc;

use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use kip::{eval, parse, EmptyResolver, RegistryBuilder};

fn registry() -> Arc<kip::Registry> {
    RegistryBuilder::from_seed().freeze()
}

fn bench_parse(c: &mut Criterion) {
    let reg = registry();
    let mut group = c.benchmark_group("parse");
    for size in [100usize, 1_000, 10_000] {
        let mut src = String::from("1 ft");
        for i in 0..size.saturating_sub(1) {
            src.push_str(" + 1 in");
            let _ = i;
        }
        group.throughput(Throughput::Elements(size as u64));
        group.bench_with_input(BenchmarkId::from_parameter(size), &src, |b, src| {
            b.iter(|| parse(black_box(src), &reg));
        });
    }
    group.finish();
}

fn bench_eval(c: &mut Criterion) {
    let reg = registry();
    let mut src = String::from("1 ft");
    for _ in 0..999 {
        src.push_str(" + 1 in");
    }
    let expr = parse(&src, &reg).expect("parse");
    let mut group = c.benchmark_group("eval");
    group.throughput(Throughput::Elements(1_000));
    group.bench_function("sum_1000_terms", |b| {
        b.iter(|| eval(black_box(expr.as_ref()), &reg, &EmptyResolver));
    });
    group.finish();
}

criterion_group!(benches, bench_parse, bench_eval);
criterion_main!(benches);