Struct ZstdBlockCompressor 

pub struct ZstdBlockCompressor { /* private fields */ }

Implementations

impl ZstdBlockCompressor

pub fn new() -> Self

Examples found in repository

examples/sample_app.rs (line 287)

fn zstd_cold_tier() {
    use subms_lsm_tree::ZstdBlockCompressor;
    println!("\n== zstd: higher-ratio compression for the cold tier ==");
    let codec = ZstdBlockCompressor::new();
    let block = "MSFT,50@320.55;".repeat(256).into_bytes();
    let encoded = codec.compress(&block).unwrap();
    println!(
        "  {} bytes -> {} compressed (level {})",
        block.len(),
        encoded.len(),
        codec.level()
    );
    assert!(encoded.len() < block.len(), "cold block shrinks");
    assert_eq!(
        codec.decompress(&encoded).unwrap(),
        block,
        "lossless round trip"
    );
}

examples/perf_features.rs (line 514)

fn feature_zstd(manifest: &mut SubMsFeatureManifest, base_p50: u64) {
    use subms_lsm_tree::ZstdBlockCompressor;

    let c = ZstdBlockCompressor::new();
    let block = representative_block();
    let sw = sweep("zstd/compress", |_| {
        keyed(
            |_| _ = black_box(c.compress(&block).expect("zstd encode")),
            true,
        )
    });
    let (cat, reason) = classify_feature(&sw, Some(base_p50), None);

    let encoded = c.compress(&block).expect("zstd encode");
    let mut p99 = BTreeMap::new();
    p99.insert(
        "compress_block".to_string(),
        keyed(
            |_| _ = black_box(c.compress(&block).expect("zstd encode")),
            false,
        ),
    );
    p99.insert(
        "decompress_block".to_string(),
        keyed(
            |_| _ = black_box(c.decompress(&encoded).expect("zstd decode")),
            false,
        ),
    );
    manifest.set_feature("zstd", cat, &p99, &reason);
}

pub fn with_level(level: i32) -> Self

pub fn level(&self) -> i32

Examples found in repository

examples/sample_app.rs (line 294)

fn zstd_cold_tier() {
    use subms_lsm_tree::ZstdBlockCompressor;
    println!("\n== zstd: higher-ratio compression for the cold tier ==");
    let codec = ZstdBlockCompressor::new();
    let block = "MSFT,50@320.55;".repeat(256).into_bytes();
    let encoded = codec.compress(&block).unwrap();
    println!(
        "  {} bytes -> {} compressed (level {})",
        block.len(),
        encoded.len(),
        codec.level()
    );
    assert!(encoded.len() < block.len(), "cold block shrinks");
    assert_eq!(
        codec.decompress(&encoded).unwrap(),
        block,
        "lossless round trip"
    );
}

pub fn compress(&self, block: &[u8]) -> Result<Vec<u8>>

Examples found in repository

examples/sample_app.rs (line 289)

fn zstd_cold_tier() {
    use subms_lsm_tree::ZstdBlockCompressor;
    println!("\n== zstd: higher-ratio compression for the cold tier ==");
    let codec = ZstdBlockCompressor::new();
    let block = "MSFT,50@320.55;".repeat(256).into_bytes();
    let encoded = codec.compress(&block).unwrap();
    println!(
        "  {} bytes -> {} compressed (level {})",
        block.len(),
        encoded.len(),
        codec.level()
    );
    assert!(encoded.len() < block.len(), "cold block shrinks");
    assert_eq!(
        codec.decompress(&encoded).unwrap(),
        block,
        "lossless round trip"
    );
}

examples/perf_features.rs (line 518)

fn feature_zstd(manifest: &mut SubMsFeatureManifest, base_p50: u64) {
    use subms_lsm_tree::ZstdBlockCompressor;

    let c = ZstdBlockCompressor::new();
    let block = representative_block();
    let sw = sweep("zstd/compress", |_| {
        keyed(
            |_| _ = black_box(c.compress(&block).expect("zstd encode")),
            true,
        )
    });
    let (cat, reason) = classify_feature(&sw, Some(base_p50), None);

    let encoded = c.compress(&block).expect("zstd encode");
    let mut p99 = BTreeMap::new();
    p99.insert(
        "compress_block".to_string(),
        keyed(
            |_| _ = black_box(c.compress(&block).expect("zstd encode")),
            false,
        ),
    );
    p99.insert(
        "decompress_block".to_string(),
        keyed(
            |_| _ = black_box(c.decompress(&encoded).expect("zstd decode")),
            false,
        ),
    );
    manifest.set_feature("zstd", cat, &p99, &reason);
}

pub fn decompress(&self, buf: &[u8]) -> Result<Vec<u8>>

Examples found in repository

examples/sample_app.rs (line 298)

fn zstd_cold_tier() {
    use subms_lsm_tree::ZstdBlockCompressor;
    println!("\n== zstd: higher-ratio compression for the cold tier ==");
    let codec = ZstdBlockCompressor::new();
    let block = "MSFT,50@320.55;".repeat(256).into_bytes();
    let encoded = codec.compress(&block).unwrap();
    println!(
        "  {} bytes -> {} compressed (level {})",
        block.len(),
        encoded.len(),
        codec.level()
    );
    assert!(encoded.len() < block.len(), "cold block shrinks");
    assert_eq!(
        codec.decompress(&encoded).unwrap(),
        block,
        "lossless round trip"
    );
}

examples/perf_features.rs (line 536)

fn feature_zstd(manifest: &mut SubMsFeatureManifest, base_p50: u64) {
    use subms_lsm_tree::ZstdBlockCompressor;

    let c = ZstdBlockCompressor::new();
    let block = representative_block();
    let sw = sweep("zstd/compress", |_| {
        keyed(
            |_| _ = black_box(c.compress(&block).expect("zstd encode")),
            true,
        )
    });
    let (cat, reason) = classify_feature(&sw, Some(base_p50), None);

    let encoded = c.compress(&block).expect("zstd encode");
    let mut p99 = BTreeMap::new();
    p99.insert(
        "compress_block".to_string(),
        keyed(
            |_| _ = black_box(c.compress(&block).expect("zstd encode")),
            false,
        ),
    );
    p99.insert(
        "decompress_block".to_string(),
        keyed(
            |_| _ = black_box(c.decompress(&encoded).expect("zstd decode")),
            false,
        ),
    );
    manifest.set_feature("zstd", cat, &p99, &reason);
}

Trait Implementations

impl Default for ZstdBlockCompressor

fn default() -> Self

Returns the “default value” for a type.