multiio 0.2.3

A unified I/O orchestration library for CLI/server applications
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

use std::sync::Arc;

use criterion::{BatchSize, Criterion, criterion_group, criterion_main};
use multiio::{ErrorPolicy, InMemorySink, InMemorySource, IoEngine, default_registry};
use serde::{Deserialize, Serialize};
use std::hint::black_box;

#[derive(Debug, Serialize, Deserialize)]
struct Config {
    name: String,
    value: i32,
}

fn make_engine(num_inputs: usize) -> IoEngine {
    let registry = default_registry();

    let json = r#"{"name": "a", "value": 1}"#;

    let mut inputs = Vec::with_capacity(num_inputs);
    for i in 0..num_inputs {
        let id = format!("in-{i}");
        let src = Arc::new(InMemorySource::from_string(id.clone(), json));
        let spec = multiio::InputSpec::new(id, src)
            .with_format(multiio::FormatKind::Json)
            .with_candidates(vec![multiio::FormatKind::Json]);
        inputs.push(spec);
    }

    let sink = Arc::new(InMemorySink::new("out"));
    let output = multiio::OutputSpec::new("out", sink)
        .with_format(multiio::FormatKind::Json)
        .with_candidates(vec![multiio::FormatKind::Json])
        .with_file_exists_policy(multiio::FileExistsPolicy::Overwrite);

    IoEngine::new(registry, ErrorPolicy::Accumulate, inputs, vec![output])
}

fn bench_engine_read_write(c: &mut Criterion) {
    let mut group = c.benchmark_group("engine_read_write_inmemory");

    for &n in &[1usize, 4, 16, 64] {
        group.bench_function(format!("read_write_{n}"), |b| {
            b.iter_batched(
                || make_engine(n),
                |engine| {
                    let values: Vec<Config> = engine.read_all().expect("read_all");
                    black_box(&values);
                    let _ = engine.write_all(&values);
                },
                BatchSize::SmallInput,
            )
        });
    }

    group.finish();
}

fn bench_engine_read_stream(c: &mut Criterion) {
    let mut group = c.benchmark_group("engine_read_stream_inmemory");

    for &n in &[1usize, 4, 16, 64] {
        group.bench_function(format!("read_stream_{n}"), |b| {
            b.iter_batched(
                || make_engine(n),
                |engine| {
                    let iter = engine.read_stream::<Config>();
                    for v in iter {
                        let v = v.expect("stream item");
                        black_box(v);
                    }
                },
                BatchSize::SmallInput,
            )
        });
    }

    group.finish();
}

criterion_group!(benches, bench_engine_read_write, bench_engine_read_stream);
criterion_main!(benches);