add seperate benchmark binary

Author: PSeitz

.gitignore

@@ -2,3 +2,4 @@
 Cargo.lock
 my-prof.profile
 Session.vim
+/benchmarks/bench_files

Cargo.toml

@@ -17,12 +17,12 @@ name = "crit_bench"
 path = "benches/crit_bench.rs"
 
 [dev-dependencies]
-criterion = "0.3.5"
-lzzzz = "1.0.2"
+criterion = "0.4.0"
+lzzzz = "1.0.4"
 lz4-compress = "0.1.1"
-more-asserts = "0.2.2"
-snap = "1.0.5"
-serde_json = "1.0.79"
+more-asserts = "0.3.1"
+snap = "1.1.0"
+serde_json = "1.0.91"
 
 [dev-dependencies.lz-fear]
 git = "https://github.com/main--/rust-lz-fear"
@@ -44,7 +44,7 @@ frame = ["std", "dep:twox-hash"]
 std = []
 
 [dependencies]
-twox-hash = { version = "1.6.2", default-features = false, optional = true }
+twox-hash = { version = "1.6.3", default-features = false, optional = true }
 
 [profile.bench]
 codegen-units = 1

benches/crit_bench.rs

@@ -17,11 +17,11 @@ const COMPRESSION10MB: &[u8] = include_bytes!("dickens.txt");
 const COMPRESSION95K_VERY_GOOD_LOGO: &[u8] = include_bytes!("../logo.jpg");
 
 const ALL: &[&[u8]] = &[
-    COMPRESSION1K as &[u8],
-    COMPRESSION34K as &[u8],
-    COMPRESSION65K as &[u8],
-    COMPRESSION66K as &[u8],
-    // COMPRESSION10MB as &[u8],
+    //COMPRESSION1K as &[u8],
+    //COMPRESSION34K as &[u8],
+    //COMPRESSION65K as &[u8],
+    //COMPRESSION66K as &[u8],
+    COMPRESSION10MB as &[u8],
     // COMPRESSION95K_VERY_GOOD_LOGO as &[u8],
 ];
 
@@ -152,20 +152,15 @@ fn bench_block_compression_throughput(c: &mut Criterion) {
             |b, i| b.iter(|| lz4_flex::compress(i)),
         );
         // an empty slice that the compiler can't infer the size
-        let empty_vec = std::env::args()
-            .nth(1000000)
-            .unwrap_or_default()
-            .into_bytes();
-        group.bench_with_input(
-            BenchmarkId::new("lz4_flex_rust_with_dict", input_bytes),
-            &input,
-            |b, i| b.iter(|| lz4_flex::block::compress_with_dict(i, &empty_vec)),
-        );
-        // group.bench_with_input(
-        //     BenchmarkId::new("lz4_flex_rust_master", input_bytes),
-        //     &input,
-        //     |b, i| b.iter(|| lz4_flex_master::compress(&i)),
-        // );
+        //let empty_vec = std::env::args()
+        //.nth(1000000)
+        //.unwrap_or_default()
+        //.into_bytes();
+        //group.bench_with_input(
+        //BenchmarkId::new("lz4_flex_rust_with_dict", input_bytes),
+        //&input,
+        //|b, i| b.iter(|| lz4_flex::block::compress_with_dict(i, &empty_vec)),
+        //);
         group.bench_with_input(
             BenchmarkId::new("lz4_redox_rust", input_bytes),
             &input,
@@ -207,20 +202,15 @@ fn bench_block_decompression_throughput(c: &mut Criterion) {
             |b, i| b.iter(|| lz4_flex::decompress(i, input.len())),
         );
         // an empty slice that the compiler can't infer the size
-        let empty_vec = std::env::args()
-            .nth(1000000)
-            .unwrap_or_default()
-            .into_bytes();
-        group.bench_with_input(
-            BenchmarkId::new("lz4_flex_rust_with_dict", input_bytes),
-            &comp_lz4,
-            |b, i| b.iter(|| lz4_flex::block::decompress_with_dict(i, input.len(), &empty_vec)),
-        );
-        // group.bench_with_input(
-        //     BenchmarkId::new("lz4_flex_rust_master", input_bytes),
-        //     &comp_lz4,
-        //     |b, i| b.iter(|| lz4_flex_master::decompress(&i, input.len())),
-        // );
+        //let empty_vec = std::env::args()
+        //.nth(1000000)
+        //.unwrap_or_default()
+        //.into_bytes();
+        //group.bench_with_input(
+        //BenchmarkId::new("lz4_flex_rust_with_dict", input_bytes),
+        //&comp_lz4,
+        //|b, i| b.iter(|| lz4_flex::block::decompress_with_dict(i, input.len(), &empty_vec)),
+        //);
         group.bench_with_input(
             BenchmarkId::new("lz4_redox_rust", input_bytes),
             &comp_lz4,

benchmarks/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "benchmarks"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+glob = "0.3.1"
+lz4_flex = { path = "../", features = [] }
+

benchmarks/download_corpus_bench.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+mkdir bench_files
+cd bench_files || exit
+wget https://sun.aei.polsl.pl//~sdeor/corpus/silesia.zip
+unzip ./silesia.zip
+rm silesia.zip
+

benchmarks/src/main.rs

@@ -0,0 +1,92 @@
+use glob::glob;
+use std::time::Duration;
+use std::{io, time::Instant};
+
+fn main() {
+    for entry in glob("bench_files/*").expect("Failed to read glob pattern") {
+        let file_name = entry.unwrap().to_str().unwrap().to_string();
+        bench_file(&file_name).unwrap();
+    }
+}
+
+fn bench_file(file: &str) -> io::Result<()> {
+    bench_compression(file)?;
+    bench_decompression(file)?;
+    Ok(())
+}
+
+fn bench_compression(file: &str) -> io::Result<()> {
+    let file_content = std::fs::read(file)?;
+    let mb = file_content.len() as f32 / 1_000_000 as f32;
+
+    let mut out = Vec::new();
+    let print_info = format!("{file} - Compression");
+
+    bench(mb, &print_info, || {
+        out.clear();
+        compress(&file_content, &mut out);
+    });
+
+    Ok(())
+}
+
+fn bench_decompression(file: &str) -> io::Result<()> {
+    let file_content = std::fs::read(file)?;
+    let mb = file_content.len() as f32 / 1_000_000 as f32;
+
+    let mut compressed = Vec::new();
+    compress(&file_content, &mut compressed);
+
+    let mut out = Vec::new();
+    let print_info = format!("{file} - Decompression");
+
+    bench(mb, &print_info, || {
+        out.clear();
+        decompress(&compressed, &mut out);
+    });
+
+    Ok(())
+}
+
+fn decompress(input: &[u8], out: &mut Vec<u8>) {
+    let mut rdr = lz4_flex::frame::FrameDecoder::new(input);
+    io::copy(&mut rdr, out).expect("I/O operation failed");
+}
+
+fn compress(input: &[u8], out: &mut Vec<u8>) {
+    let mut wtr = lz4_flex::frame::FrameEncoder::new(out);
+
+    io::copy(&mut &input[..], &mut wtr).expect("I/O operation failed");
+    wtr.finish().unwrap();
+}
+
+fn bench<F>(mb: f32, print_info: &str, mut do_stuff: F)
+where
+    F: FnMut(),
+{
+    let start = Instant::now();
+    let mut last_print = Instant::now();
+
+    let mut loops = 0;
+    loop {
+        let start_loop = Instant::now();
+
+        do_stuff();
+
+        let after_comp = Instant::now();
+
+        let elapsed_since_last_print: Duration = after_comp - last_print;
+        if elapsed_since_last_print.as_secs_f32() > 1.0 {
+            let elapsed_since_loop_start: Duration = after_comp - start_loop;
+            let through_put = mb as f32 / elapsed_since_loop_start.as_secs_f32();
+            println!("{print_info} {:.2} Mb/s", through_put);
+            last_print = Instant::now();
+        }
+
+        loops += 1;
+        let secs_since_start = (Instant::now() - start).as_secs_f32();
+        if secs_since_start > 5.0 || loops > 1000 {
+            break;
+        }
+    }
+}