add: all sources

Author: dalvangriebler

LICENSE.md

@@ -0,0 +1,27 @@
+MIT License
+
+Copyright (c) 2021 Parallel Applications Modelling Group - GMAP
+
+ GMAP website: https://gmap.pucrs.br
+	
+ Pontifical Catholic University of Rio Grande do Sul (PUCRS)
+ 
+ Av. Ipiranga, 6681, Porto Alegre - Brazil, 90619-900
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1 +1,57 @@
-# RustSreamBench
+# Rust Stream Bench
+
+**The Rust Stream Bench** is a benchmark suite for evaluating stream parallelism on parallel APIs available in **Rust** language. Our [paper](https://doi.org/10.1016/j.cola.2021.101054) contains abundant information about the benchmark applications and workload characteristics. In the paper, we also discussed the methodology used and the outcome of performance evaluation. **You can use our paper as a guide to assess performance on different Rust features using this benchmark suite.**
+
+This project was conducted in the Parallel Applications Modelling Group (GMAP) at PUCRS - Brazil.
+
+## How to cite this work
+  
+[[DOI]](https://doi.org/10.1016/j.cola.2021.101054) R. Pieper, J. Löff, R.B. Hoffmann, D. Grieble, L. G. Fernandes. **High-level and efficient structuredstream parallelism for rust on multi-cores**, *Journal of Computer Languages (COLA)* (2021)
+
+*You can also contribute with this project, writing issues and pull requests.*
+
+# The Four Benchmark Applications
+
+- **Micro-bench** - Is a mathematical synthetic application that was designed using a fractal in the complex plane, namely the Mandelbrot set. Contains unbalanced workload that requires efficient schedulers.
+
+- **Image Processing** - Is characterized by a stream of images flowing through 5 different filters: Saturation, Emboss, GammaCorrection, Sharpen, and Grayscale. Some filters may take longer than others to complete and all of them are stateless.
+
+- **Bzip2** - Is an important open-source tool for loss-less data compression/decompression. Compression is computationally costly whereas the decompression is shipper. Also, performance heavily depends on the characteristics of the input file. 
+
+- **Eye Detector** - Is a video processing application that detects the eyes in the faces within an input video. Performance heavily depends on the characteristics of the input video. More faces in the video require more computational power. 
+
+_Tip: Find more information in our [paper](https://doi.org/10.1016/j.cola.2021.101054)_
+
+## Folders inside the  project
+
+- **bzip2** - This directory contains the *Bzip2* benchmark application with suitable parallel implementations.
+- **eye-detector** - This directory contains the *Eye Detector* benchmark application with suitable parallel implementations.
+- **image-processing** - This directory contains the *Image Processing* benchmark application with suitable parallel implementations.
+- **micro-bench** - This directory contains the *Micro-bench* benchmark application with suitable parallel implementations.
+- **libs** - This directory contains our *Rust-SSP* parallel programming API lib and *OpenCV* installation script for the _Eye Detector_ application.
+
+
+# How to Compile 
+
+Programs can be compiled using default Cargo Rust package manager.
+Inside each application directory, you may do so using:
+	`$ cargo build --release`
+
+# How to Execute
+
+You can find information about how to compile and execute the applications in a `README.md` inside each folder.
+
+Besides we provide the input workloads we used in our experimental evaluation. You can download them using the `get_inputs.sh` script that is within each application folder. Except Micro-bench, which does not require any input source.
+
+# How to install OpenCV
+
+You can install OpenCV version 4.5 and Rust wrapper following these steps:
+
+`$ cd libs/`
+
+`$ source setup_opencv_with_ffmpeg.sh`
+
+`$ source config_opencv_vars.sh`
+
+Remember to adjust the COMPILE_THREADS variable inside the `setup_opencv_with_ffmpeg.sh` script accordingly.
+Whenever you open a new session, you will need to set OpenCV enviromental variables with `config_opencv_vars.sh` script.

bzip2/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "bzip2"
+version = "0.1.0"
+edition = "2018"
+authors = ["Dalvan Griebler <[email protected]>",
+		   "Júnior Löff <[email protected]>",
+	   	   "Renato B. Hoffmann <[email protected]>"]
+license = "MIT"
+repository = "https://github.com/GMAP/RustStreamBench"
+readme = "README.md"
+
+[dependencies]
+chrono = "0.4"
+libc = "0.2"
+bzip2-sys = { version = "0.1.7", path = "bzip2-sys" }
+
+# Rust-SSP
+rust-spp = { path = "~/../../libs/rust-ssp" }
+
+# Rust Standard Library + Crossbeam
+crossbeam-channel = "0.5"
+crossbeam-utils = "0.8"
+
+# Tokio
+tokio = "0.1.19"
+futures = "0.1"
+tokio-core = "0.1.17"
+
+# Rayon
+rayon = "1.5"
+
+# Pipeliner
+pipeliner = "1.0.1"

bzip2/README.md

@@ -0,0 +1,38 @@
+# Bzip2 #
+
+Bzip2 application in RUST.
+
+This application compresses and decompresses files using bzip2.
+
+Bzip2 core routines contain binddings to libbz2. This library is provided by Bzip2 for Rust (https://crates.io/crates/bzip2).
+
+# Inputs
+
+Input is a directory of files that can be compressed and decompressed using Bzip2.
+
+You may get the inputs using the `get_inputs.sh` shell script.
+
+We provide workloads with different behaviours. You will find more information about the workload characteristics in our paper.
+
+
+# List of dependencies
+
+	llvm
+	clang 
+	libclang-dev
+	bzip2-sys
+	Other dependencies in Cargo.toml file
+
+# Basic commands for running
+	cargo build --release
+	./<path_to_binary> <runtime> <nthreads> <compress/decompress> <input_file>
+
+Options for `runtime` are: 
+	"sequential", or "rust-ssp", or "pipeliner", or "tokio", or "rayon", or "std-threads"
+
+Alternative `runtime` options are (see paper):
+	"sequential-io", or "rust-ssp-io", or "tokio-io", or "std-threads-io"
+
+Command example:
+
+`$ ./target/release/bzip2 rust-ssp 4 compress iso_file.iso`

bzip2/bzip2-sys/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "bzip2-sys"
+version = "0.1.9+1.0.8"
+authors = ["Alex Crichton <[email protected]>"]
+links = "bzip2"
+build = "build.rs"
+license = "MIT/Apache-2.0"
+repository = "https://github.com/alexcrichton/bzip2-rs"
+homepage = "https://github.com/alexcrichton/bzip2-rs"
+documentation = "https://docs.rs/bzip2-sys"
+description = """
+Bindings to libbzip2 for bzip2 compression and decompression exposed as
+Reader/Writer streams.
+"""
+categories = ["external-ffi-bindings"]
+
+[lib]
+name = "bzip2_sys"
+path = "lib.rs"
+
+[dependencies]
+libc = "0.2"
+
+[build-dependencies]
+pkg-config = "0.3.9"
+cc = "1.0"

bzip2/bzip2-sys/LICENSE-APACHE

@@ -0,0 +1 @@
+../LICENSE-APACHE

bzip2/bzip2-sys/LICENSE-MIT

@@ -0,0 +1 @@
+../LICENSE-MIT

bzip2/bzip2-sys/build.rs

@@ -0,0 +1,46 @@
+extern crate cc;
+extern crate pkg_config;
+
+use std::path::PathBuf;
+use std::{env, fs};
+
+fn main() {
+    let mut cfg = cc::Build::new();
+    let target = env::var("TARGET").unwrap();
+    cfg.warnings(false);
+
+    if target.contains("windows") {
+        cfg.define("_WIN32", None);
+        cfg.define("BZ_EXPORT", None);
+    } else {
+        if pkg_config::Config::new()
+            .cargo_metadata(true)
+            .probe("bzip2")
+            .is_ok()
+        {
+            return;
+        }
+    }
+
+    let dst = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+
+    cfg.include("bzip2-1.0.8")
+        .define("_FILE_OFFSET_BITS", Some("64"))
+        .define("BZ_NO_STDIO", None)
+        .file("bzip2-1.0.8/blocksort.c")
+        .file("bzip2-1.0.8/huffman.c")
+        .file("bzip2-1.0.8/crctable.c")
+        .file("bzip2-1.0.8/randtable.c")
+        .file("bzip2-1.0.8/compress.c")
+        .file("bzip2-1.0.8/decompress.c")
+        .file("bzip2-1.0.8/bzlib.c")
+        .out_dir(dst.join("lib"))
+        .compile("libbz2.a");
+
+    let src = env::current_dir().unwrap().join("bzip2-1.0.8");
+    let include = dst.join("include");
+    fs::create_dir_all(&include).unwrap();
+    fs::copy(src.join("bzlib.h"), dst.join("include/bzlib.h")).unwrap();
+    println!("cargo:root={}", dst.display());
+    println!("cargo:include={}", dst.join("include").display());
+}