harn-vm 0.9.13

Async bytecode virtual machine for the Harn programming language
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
115
116
117

use std::hint::black_box;

use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use harn_vm::{compile_source, register_vm_stdlib, Chunk, Vm, VmValue};
use tokio::runtime::{Builder, Runtime};

const TASKS: usize = 16;
const INNER_ITERS: usize = 90_000;

fn crunch_function() -> String {
    format!(
        r#"
fn crunch(seed) {{
  var i = 0
  var total = seed + 1
  while i < {INNER_ITERS} {{
    total = ((total * 1664525) + i + 1013904223) % 2147483647
    i = i + 1
  }}
  return {{
    seed: seed,
    total: total,
    payload: [seed, total, "pool-parallel"]
  }}
}}
"#
    )
}

fn serial_source() -> String {
    format!(
        r"
{}

pipeline default() {{
  var results = []
  for i in 0 to {TASKS} exclusive {{
    results = results.push(crunch(i))
  }}
  return len(results)
}}
",
        crunch_function()
    )
}

fn pool_source(max_concurrent: usize) -> String {
    format!(
        r#"
import {{ pool_create, pool_wait }} from "std/lifecycle/pool"

{}

pipeline default() {{
  let pool = pool_create({{name: "pool-parallel-bench", max_concurrent: {max_concurrent}}})
  var handles = []
  for i in 0 to {TASKS} exclusive {{
    let seed = i
    handles = handles.push(pool.submit({{ -> crunch(seed) }}))
  }}
  let results = pool_wait(handles)
  return len(results)
}}
"#,
        crunch_function()
    )
}

fn compile_pool_fixture(max_concurrent: usize) -> Chunk {
    compile_source(&pool_source(max_concurrent)).expect("pool parallel bench fixture compiles")
}

fn compile_serial_fixture() -> Chunk {
    compile_source(&serial_source()).expect("serial pool baseline bench fixture compiles")
}

fn runtime() -> Runtime {
    Builder::new_multi_thread()
        .worker_threads(4)
        .enable_all()
        .build()
        .expect("pool parallel bench runtime")
}

fn execute(rt: &Runtime, chunk: &Chunk) -> VmValue {
    harn_vm::reset_thread_local_state();
    rt.block_on(async {
        let mut vm = Vm::new();
        register_vm_stdlib(&mut vm);
        vm.execute(chunk).await.expect("pool fixture executes")
    })
}

fn bench_pool_parallel(c: &mut Criterion) {
    let mut group = c.benchmark_group("pool_parallel_cpu_fanout");
    group.throughput(Throughput::Elements(TASKS as u64));
    let serial_chunk = compile_serial_fixture();
    let serial_rt = runtime();
    group.bench_function(BenchmarkId::new("serial", 1), |b| {
        b.iter(|| black_box(execute(&serial_rt, &serial_chunk)));
    });
    for workers in [1_usize, 2, 4] {
        let chunk = compile_pool_fixture(workers);
        let rt = runtime();
        group.bench_with_input(BenchmarkId::from_parameter(workers), &workers, |b, _| {
            b.iter(|| black_box(execute(&rt, &chunk)));
        });
    }
    group.finish();
}

criterion_group! {
    name = benches;
    config = Criterion::default().sample_size(10);
    targets = bench_pool_parallel
}
criterion_main!(benches);