Merge pull request #1656 from Kobzol/runtime-svg

Add SVG parsing and rendering runtime benchmark

Author: Kobzol

Cargo.lock

@@ -14,6 +14,10 @@ log = "0.4.17"
 env_logger = "0.10.0"
 clap = { version = "4.1", features = ["derive", "string"] }
 libc = "0.2"
+flate2 = { version = "1", optional = true }
 
 [target.'cfg(target_os = "linux")'.dependencies]
 perf-event = "0.4.7"
+
+[features]
+compression = ["dep:flate2"]

collector/benchlib/Cargo.toml

@@ -18,3 +18,7 @@ mod cli;
 pub mod comm;
 pub mod measure;
 pub mod process;
+mod utils;
+
+#[cfg(feature = "compression")]
+pub use utils::decompress_file;

collector/benchlib/src/lib.rs

@@ -0,0 +1,12 @@
+/// Decompresses the contents of a gzipped (.gz) file.
+#[cfg(feature = "compression")]
+pub fn decompress_file(contents: &[u8]) -> Vec<u8> {
+    use std::io::Read;
+
+    let mut tar = flate2::bufread::GzDecoder::new(contents);
+    let mut result = Vec::new();
+    tar.read_to_end(&mut result)
+        .expect("Cannot decompress file");
+
+    result
+}

collector/benchlib/src/utils.rs

@@ -22,3 +22,15 @@ not print anything to `stdout`!
 Note that each benchmark group binary will be thus invoked twice per benchmarking collection. Keep this
 in mind so that the `main` function of the group doesn't perform too much work, which will be thrown
 away when it is invoked with the `list` argument.
+
+## Benchmark input files
+Some benchmarks will need input files. Ideally, these should be stored directly inside this repository,
+e.g. in a `data` directory under the benchmark group workspace root. If some files are shared between
+multiple groups, you can put them in the `runtime-benchmarks/data` directory. To keep benchmarks
+self-contained, consider including the input files directly into the binary using the `include_bytes!`
+or `include_str!` macros.
+
+Try to keep the sizes of input files reasonable. If you want to increase their size for the benchmark,
+you can repeat their contents at the beginning of the benchmark run (in `main`). If the file has a
+format that is not easily repeatable it is large (e.g. larger than 1 MiB), consider compressing it
+using `gzip <file>` and them decompressing it in `main` using `benchlib::decompress_file`.

collector/runtime-benchmarks/README.md

@@ -6,7 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-benchlib = { path = "../../benchlib" }
+benchlib = { path = "../../benchlib", features = ["compression"] }
 brotli = "3.3.4"
 
 [workspace]

collector/runtime-benchmarks/compression/Cargo.lock

@@ -3,8 +3,9 @@ use std::io::Write;
 use brotli::enc::BrotliEncoderParams;
 
 use benchlib::benchmark::run_benchmark_group;
+use benchlib::decompress_file;
 
-const TEXT_SHERLOCK: &str = include_str!("../../data/sherlock.txt");
+const TEXT_SHERLOCK: &[u8] = include_bytes!("../../data/sherlock.txt.gz");
 
 fn compress(data: &str) -> Vec<u8> {
     let mut target: Vec<u8> = Vec::with_capacity(1024 * 1024);
@@ -18,19 +19,22 @@ fn compress(data: &str) -> Vec<u8> {
 }
 
 fn main() {
+    let sherlock_text = String::from_utf8(decompress_file(TEXT_SHERLOCK)).expect("Invalid UTF-8");
     // Decompression is much faster than compression, so inflate the data a bit
-    let compressed_text = compress(&TEXT_SHERLOCK.repeat(20));
+    let compressed_text = compress(&sherlock_text.repeat(20));
 
     run_benchmark_group(|group| {
         group.register_benchmark("brotli-compress", || {
             let mut target_buffer: Vec<u8> = Vec::with_capacity(1024 * 1024);
             let mut params = BrotliEncoderParams::default();
             params.quality = 10;
 
+            let mut text = sherlock_text.as_bytes();
+
             move || {
                 let mut writer =
                     brotli::CompressorWriter::with_params(&mut target_buffer, 4096, &params);
-                std::io::copy(&mut TEXT_SHERLOCK.as_bytes(), &mut writer).unwrap();
+                std::io::copy(&mut text, &mut writer).unwrap();
                 writer.flush().unwrap();
                 drop(writer);
                 target_buffer