tedium 0.2.0

A fast and easy TDMS Library for Rust
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

use criterion::{Criterion, black_box, criterion_group};
use std::io::Cursor;
use tedium::{ChannelPath, DataLayout, TdmsFile};

fn create_file(elements: usize, channels: usize) -> TdmsFile<Cursor<Vec<u8>>> {
    let buffer = (0..elements).map(|i| i as f64).collect::<Vec<_>>();

    let mut file = TdmsFile::new(Cursor::new(Vec::new())).unwrap();
    let mut writer = file.writer().unwrap();

    let channels = (0..channels)
        .map(|index| ChannelPath::new("group", &format!("channel{}", index)))
        .collect::<Vec<_>>();
    writer
        .write_channels(&channels, &buffer[..], DataLayout::Contigious)
        .unwrap();
    drop(writer);
    file
}

fn single_channel_segment(c: &mut Criterion) {
    let elements = 1_000_000;
    let mut file = create_file(elements, 1);
    let mut output = vec![0.0f64; elements];

    let mut group = c.benchmark_group("Single Channel Segment - Contigious");
    group.throughput(criterion::Throughput::Bytes(
        elements as u64 * std::mem::size_of::<f64>() as u64,
    ));

    group.bench_function("read single from single", |b| {
        b.iter(|| {
            file.read_channel(
                &ChannelPath::new("group", "channel0"),
                black_box(&mut output[..]),
            )
            .unwrap()
        });
    });
}

fn multi_channel_segment(c: &mut Criterion) {
    let elements = 1_000_000;
    let channels = 4;
    let elements_all = elements * channels;
    let mut file = create_file(elements_all, channels);
    let mut output = vec![0.0f64; elements];
    let mut output1 = vec![0.0f64; elements];
    let mut output2 = vec![0.0f64; elements];
    let mut output3 = vec![0.0f64; elements];

    let mut group = c.benchmark_group("Multi Channel Segment - Contigious");
    group.throughput(criterion::Throughput::Bytes(
        elements as u64 * std::mem::size_of::<f64>() as u64,
    ));

    group.bench_function("read single from multi", |b| {
        b.iter(|| {
            file.read_channel(
                &ChannelPath::new("group", "channel0"),
                black_box(&mut output[..]),
            )
            .unwrap()
        });
    });

    group.throughput(criterion::Throughput::Bytes(
        elements_all as u64 * std::mem::size_of::<f64>() as u64,
    ));
    group.bench_function("read all from multi", |b| {
        b.iter(|| {
            file.read_channels(
                &[
                    &ChannelPath::new("group", "channel0"),
                    &ChannelPath::new("group", "channel1"),
                    &ChannelPath::new("group", "channel2"),
                    &ChannelPath::new("group", "channel3"),
                ],
                &mut [
                    black_box(&mut output[..]),
                    black_box(&mut output1[..]),
                    black_box(&mut output2[..]),
                    black_box(&mut output3[..]),
                ],
            )
            .unwrap();
        });
    });
}

criterion_group!(
    contiguous_reader,
    single_channel_segment,
    multi_channel_segment
);