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
46

//! Parallel scaling on a synthetic 1,000-expression sheet (M8).

use std::sync::Arc;

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

fn build_sheet(n: usize, reg: &kip::Registry) -> Vec<Arc<kip::Expr>> {
    (0..n)
        .map(|i| parse(&format!("{i} in + 1 ft"), reg).expect("parse"))
        .collect()
}

fn bench_parallel_sheet(c: &mut Criterion) {
    let reg = registry();
    let sheet = build_sheet(1_000, &reg);

    let mut group = c.benchmark_group("parallel_sheet_1000");
    group.throughput(Throughput::Elements(1_000));

    group.bench_function("serial", |b| {
        b.iter(|| {
            sheet
                .iter()
                .map(|expr| eval(black_box(expr.as_ref()), &reg, &EmptyResolver))
                .collect::<Vec<_>>()
        });
    });

    #[cfg(feature = "parallel")]
    group.bench_function("eval_batch", |b| {
        b.iter(|| {
            let refs: Vec<_> = sheet.iter().map(|e| e.as_ref()).collect();
            eval_batch(black_box(refs), &reg, &EmptyResolver)
        });
    });

    group.finish();
}

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

criterion_group!(benches, bench_parallel_sheet);
criterion_main!(benches);