zrip 0.2.1

Pure Rust zstd codec: Fast/DFast strategies (levels -7..4), COVER/FastCOVER dict builder
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

use std::time::Instant;

fn main() {
    let path = std::env::args()
        .nth(1)
        .unwrap_or("corpus/dickens.txt".into());
    let data = std::fs::read(&path).expect("file not found");
    let name = path.rsplit('/').next().unwrap();

    let c_compressed = zstd::encode_all(&data[..], 1).unwrap();
    let mut zrip_ctx = zrip::CompressContext::new(1).unwrap();
    let z_compressed = zrip_ctx.compress(&data).unwrap().to_vec();

    eprintln!(
        "{name}: input={}, C zstd={}, zrip={}",
        data.len(),
        c_compressed.len(),
        z_compressed.len()
    );

    let decoded = zrip::decompress(&c_compressed).unwrap();
    assert_eq!(decoded.len(), data.len());
    assert_eq!(&decoded[..], &data[..]);

    let cap = data.len() + 1024;
    let iters = 200;

    // zrip decoding C-zstd data
    for _ in 0..5 {
        let _ =
            std::hint::black_box(zrip::decompress(std::hint::black_box(&c_compressed)).unwrap());
    }
    let mut times: Vec<u128> = (0..iters)
        .map(|_| {
            let t = Instant::now();
            let _ = std::hint::black_box(
                zrip::decompress(std::hint::black_box(&c_compressed)).unwrap(),
            );
            t.elapsed().as_nanos()
        })
        .collect();
    times.sort();
    let zrip_c_ns = times[iters / 2];

    // zrip decoding zrip data
    for _ in 0..5 {
        let _ =
            std::hint::black_box(zrip::decompress(std::hint::black_box(&z_compressed)).unwrap());
    }
    let mut times: Vec<u128> = (0..iters)
        .map(|_| {
            let t = Instant::now();
            let _ = std::hint::black_box(
                zrip::decompress(std::hint::black_box(&z_compressed)).unwrap(),
            );
            t.elapsed().as_nanos()
        })
        .collect();
    times.sort();
    let zrip_z_ns = times[iters / 2];

    // C zstd decoding C-zstd data
    let mut dec = zstd::bulk::Decompressor::new().unwrap();
    let mut buf = Vec::with_capacity(cap);
    for _ in 0..5 {
        buf.clear();
        dec.decompress_to_buffer(&c_compressed, &mut buf).unwrap();
    }
    let mut times: Vec<u128> = (0..iters)
        .map(|_| {
            buf.clear();
            let t = Instant::now();
            let _ = std::hint::black_box(
                dec.decompress_to_buffer(std::hint::black_box(&c_compressed), &mut buf)
                    .unwrap(),
            );
            t.elapsed().as_nanos()
        })
        .collect();
    times.sort();
    let c_c_ns = times[iters / 2];

    let mb = data.len() as f64 / 1e6;
    eprintln!("--- Same input (C-zstd compressed) ---");
    eprintln!(
        "C zstd:  {:>7.1} MB/s  ({:.0} µs)",
        mb / (c_c_ns as f64 / 1e9),
        c_c_ns as f64 / 1e3
    );
    eprintln!(
        "zrip:    {:>7.1} MB/s  ({:.0} µs)  [{:.0}% of C]",
        mb / (zrip_c_ns as f64 / 1e9),
        zrip_c_ns as f64 / 1e3,
        100.0 * c_c_ns as f64 / zrip_c_ns as f64
    );
    eprintln!("");
    eprintln!("--- zrip-compressed input ---");
    eprintln!(
        "zrip:    {:>7.1} MB/s  ({:.0} µs)",
        mb / (zrip_z_ns as f64 / 1e9),
        zrip_z_ns as f64 / 1e3
    );
}