openigtlink-rust 0.2.0

Rust implementation of the OpenIGTLink protocol for image-guided therapy
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

//! Compression performance benchmarks
//!
//! Measures compression/decompression speed and ratios.

use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
use openigtlink_rust::compression::{compress, decompress, CompressionLevel, CompressionType};

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

    let sizes = vec![
        (1024, "1KB"),
        (10 * 1024, "10KB"),
        (100 * 1024, "100KB"),
        (1024 * 1024, "1MB"),
    ];

    for (size, name) in sizes {
        group.throughput(Throughput::Bytes(size as u64));

        // Use gradient data (moderately compressible)
        let data: Vec<u8> = (0..size).map(|i| (i / 100) as u8).collect();

        group.bench_with_input(BenchmarkId::from_parameter(name), &data, |b, data| {
            b.iter(|| {
                black_box(
                    compress(data, CompressionType::Deflate, CompressionLevel::Default).unwrap(),
                )
            });
        });
    }

    group.finish();
}

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

    let sizes = vec![
        (1024, "1KB"),
        (10 * 1024, "10KB"),
        (100 * 1024, "100KB"),
        (1024 * 1024, "1MB"),
    ];

    for (size, name) in sizes {
        group.throughput(Throughput::Bytes(size as u64));

        let data: Vec<u8> = (0..size).map(|i| (i / 100) as u8).collect();
        let compressed =
            compress(&data, CompressionType::Deflate, CompressionLevel::Default).unwrap();

        group.bench_with_input(
            BenchmarkId::from_parameter(name),
            &compressed,
            |b, compressed| {
                b.iter(|| black_box(decompress(compressed, CompressionType::Deflate).unwrap()));
            },
        );
    }

    group.finish();
}

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

    let data: Vec<u8> = (0..100_000).map(|i| (i / 100) as u8).collect();
    group.throughput(Throughput::Bytes(data.len() as u64));

    let levels = vec![
        (CompressionLevel::Fast, "fast"),
        (CompressionLevel::Default, "default"),
        (CompressionLevel::Best, "best"),
    ];

    for (level, name) in levels {
        group.bench_with_input(BenchmarkId::from_parameter(name), &data, |b, data| {
            b.iter(|| black_box(compress(data, CompressionType::Deflate, level).unwrap()));
        });
    }

    group.finish();
}

criterion_group!(
    benches,
    bench_compression_by_size,
    bench_decompression_by_size,
    bench_compression_levels
);

criterion_main!(benches);