Merge pull request #50 from orxfun/redesigning-parallel-traits

Redesigning parallel traits

Author: orxfun

.github/workflows/ci.yml

@@ -0,0 +1,56 @@
+name: Rust
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        toolchain: ["stable"]
+        features: ["", "--features generic_iterator"]
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Install toolchain
+      uses: dtolnay/rust-toolchain@master
+      with:
+        toolchain: ${{ matrix.toolchain }}
+
+    - name: Install 32bit target
+      run: rustup target add i686-unknown-linux-musl
+    - name: Install wasm target
+      run: rustup target add wasm32-unknown-unknown
+    - name: Install miri
+      run: rustup component add --toolchain nightly-x86_64-unknown-linux-gnu miri
+    - name: Install no-std-check
+      run: cargo install cargo-no-std-check
+      
+    - name: Build
+      run: cargo build --verbose ${{ matrix.features }}
+    - name: Build-32bit
+      run: cargo build --verbose --target i686-unknown-linux-musl ${{ matrix.features }}
+    - name: Build-wasm
+      run: cargo build --verbose --target wasm32-unknown-unknown ${{ matrix.features }}
+
+    - name: Test
+      run: cargo test --verbose ${{ matrix.features }}
+    - name: Test-32bit
+      run: cargo test --verbose --target i686-unknown-linux-musl ${{ matrix.features }}
+    - name: Check-wasm
+      run: cargo check --verbose --target wasm32-unknown-unknown ${{ matrix.features }}
+
+    - name: Clippy
+      run: cargo clippy ${{ matrix.features }} -- -D warnings --verbose
+
+    - name: Miri
+      run: cargo +nightly miri test --lib --bins --tests --verbose ${{ matrix.features }}

Cargo.toml

@@ -1,34 +1,42 @@
 [package]
 name = "orx-parallel"
-version = "1.16.0"
-edition = "2021"
+version = "2.0.0"
+edition = "2024"
 authors = ["orxfun <[email protected]>"]
-description = "A performant and configurable parallel computing library for computations defined as compositions of iterator methods."
+readme = "README.md"
+description = "High performance, configurable and expressive parallel computation library."
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/orxfun/orx-parallel/"
 keywords = ["parallel", "concurrency", "performance", "thread", "iterator"]
 categories = ["concurrency", "algorithms"]
 
 [dependencies]
-orx-pseudo-default = { version = "2.0.0", default-features = false }
-orx-pinned-vec = "3.15"
-orx-fixed-vec = "3.15"
-orx-split-vec = "3.15"
-orx-pinned-concurrent-col = "2.12"
-orx-concurrent-bag = "2.11"
-orx-concurrent-ordered-bag = "2.11"
-orx-priority-queue = "1.5.0"
-orx-concurrent-iter = "1.30.0"
+orx-pseudo-default = { version = "2.1.0", default-features = false }
+orx-pinned-vec = "3.16.0"
+orx-fixed-vec = "3.16.0"
+orx-split-vec = "3.16.0"
+orx-pinned-concurrent-col = "2.13.0"
+orx-concurrent-bag = "2.12.0"
+orx-concurrent-ordered-bag = "2.12.0"
+orx-iterable = "1.3.0"
+orx-priority-queue = "1.7.0"
+orx-concurrent-iter = "2.0.0"
+rayon = { version = "1.10.0", optional = true }
 
 [dev-dependencies]
 chrono = "0.4.39"
+clap = { version = "4.5.36", features = ["derive"] }
 criterion = "0.5.1"
-orx-iterable = "1.2.0"
-rand = "0.8"
-rand_chacha = "0.3"
+orx-concurrent-vec = "3.6.0"
+rand = "0.9"
+rand_chacha = "0.9"
 rayon = "1.10.0"
 test-case = "3.3.1"
 
 [[bench]]
-name = "flatmap"
+name = "reduce_iter_into_par"
 harness = false
+
+[features]
+default = []
+generic_iterator = ["rayon"]

README.md

@@ -0,0 +1,122 @@
+use criterion::{BenchmarkId, Criterion, black_box, criterion_group, criterion_main};
+use orx_parallel::*;
+use orx_split_vec::SplitVec;
+use rand::prelude::*;
+use rand_chacha::ChaCha8Rng;
+use rayon::iter::IntoParallelIterator;
+
+const TEST_LARGE_OUTPUT: bool = false;
+
+const LARGE_OUTPUT_LEN: usize = match TEST_LARGE_OUTPUT {
+    true => 64,
+    false => 0,
+};
+const SEED: u64 = 5426;
+const FIB_UPPER_BOUND: u32 = 201;
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+struct Output {
+    name: String,
+    numbers: [i64; LARGE_OUTPUT_LEN],
+}
+
+fn to_output(idx: &usize) -> Output {
+    let idx = *idx;
+    let prefix = match idx % 7 {
+        0 => "zero-",
+        3 => "three-",
+        _ => "sth-",
+    };
+    let fib = fibonacci(&(idx as u32));
+    let name = format!("{}-fib-{}", prefix, fib);
+
+    let mut numbers = [0i64; LARGE_OUTPUT_LEN];
+    for (i, x) in numbers.iter_mut().enumerate() {
+        *x = match (idx * 7 + i) % 3 {
+            0 => idx as i64 + i as i64,
+            _ => idx as i64 - i as i64,
+        };
+    }
+
+    Output { name, numbers }
+}
+
+fn filter(output: &&Output) -> bool {
+    let last_char = output.name.chars().last().unwrap();
+    let last_digit: u32 = last_char.to_string().parse().unwrap();
+    last_digit < 4
+}
+
+fn fibonacci(n: &u32) -> u32 {
+    let mut a = 0;
+    let mut b = 1;
+    for _ in 0..*n {
+        let c = a + b;
+        a = b;
+        b = c;
+    }
+    a
+}
+
+fn inputs(len: usize) -> Vec<Output> {
+    let mut rng = ChaCha8Rng::seed_from_u64(SEED);
+    (0..len)
+        .map(|_| rng.random_range(0..FIB_UPPER_BOUND) as usize)
+        .map(|x| to_output(&x))
+        .collect()
+}
+
+fn seq(inputs: &[Output]) -> Vec<&Output> {
+    inputs.iter().filter(filter).collect()
+}
+
+fn rayon(inputs: &[Output]) -> Vec<&Output> {
+    use rayon::iter::ParallelIterator;
+    inputs.into_par_iter().filter(filter).collect()
+}
+
+fn orx_into_vec(inputs: &[Output]) -> Vec<&Output> {
+    inputs.into_par().filter(filter).collect()
+}
+
+fn orx_into_split_vec(inputs: &[Output]) -> SplitVec<&Output> {
+    inputs.into_par().filter(filter).collect()
+}
+
+fn run(c: &mut Criterion) {
+    let treatments = [65_536, 65_536 * 4];
+
+    let mut group = c.benchmark_group("collect_filter");
+
+    for n in &treatments {
+        let input = inputs(*n);
+        let expected = seq(&input);
+        let mut sorted = seq(&input);
+        sorted.sort();
+
+        group.bench_with_input(BenchmarkId::new("seq-into-vec", n), n, |b, _| {
+            assert_eq!(&expected, &seq(&input));
+            b.iter(|| seq(black_box(&input)))
+        });
+
+        group.bench_with_input(BenchmarkId::new("rayon-into-vec", n), n, |b, _| {
+            assert_eq!(&expected, &rayon(&input));
+            b.iter(|| rayon(black_box(&input)))
+        });
+
+        group.bench_with_input(BenchmarkId::new("orx-vec", n), n, |b, _| {
+            assert_eq!(&expected, &orx_into_vec(&input));
+            b.iter(|| orx_into_vec(black_box(&input)))
+        });
+
+        group.bench_with_input(BenchmarkId::new("orx-split-vec", n), n, |b, _| {
+            assert_eq!(&expected, &orx_into_split_vec(&input));
+            b.iter(|| orx_into_split_vec(black_box(&input)))
+        });
+    }
+
+    group.finish();
+}
+
+criterion_group!(benches, run);
+criterion_main!(benches);