orx-imp-vec 2.17.0

`ImpVec` stands for immutable push vector 👿, it is a data structure which allows appending elements with a shared reference.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

// cargo run --release --example bench_parallelization
// cargo run --release --example bench_parallelization -- --help
// cargo run --release --example bench_parallelization -- --len 50000 --num-repetitions 20

mod utils;

use clap::Parser;
use orx_imp_vec::*;
use orx_parallel::*;
use utils::timed_collect_all;

#[derive(Parser, Debug)]
struct Args {
    /// Number of items in the input iterator.
    #[arg(long, default_value_t = 1_000_000)]
    len: usize,
    /// Number of repetitions to measure time; total time will be reported.
    #[arg(long, default_value_t = 100)]
    num_repetitions: usize,
}

fn fibonacci(n: usize) -> usize {
    let mut a = 0;
    let mut b = 1;
    for _ in 0..n {
        let c = a + b;
        a = b;
        b = c;
    }
    a
}

fn main() {
    let args = Args::parse();

    let expected_output = {
        let split_vec: SplitVec<_> = (0..args.len as usize).collect();

        split_vec
            .into_iter()
            .filter(|x| x % 3 != 0)
            .map(|x| x + fibonacci(x % 40))
            .filter_map(|x| (x % 2 == 0).then(|| x.to_string()))
            .collect::<Vec<_>>()
    };

    let computations: Vec<(&str, Box<dyn Fn() -> Vec<String>>)> = vec![
        (
            "Sequential over Vec",
            Box::new(move || {
                let split_vec: SplitVec<_> = (0..args.len as usize).collect();

                split_vec
                    .into_iter()
                    .filter(|x| x % 3 != 0)
                    .map(|x| x + fibonacci(x % 40))
                    .filter_map(|x| (x % 2 == 0).then(|| x.to_string()))
                    .collect::<Vec<_>>()
            }),
        ),
        (
            "Parallelized over Vec using orx_parallel",
            Box::new(move || {
                let vec: Vec<_> = (0..args.len as usize).collect();

                vec.into_par()
                    .filter(|x| *x % 3 != 0)
                    .map(|x| x + fibonacci(x % 40))
                    .filter_map(|x| (x % 2 == 0).then(|| x.to_string()))
                    .collect::<Vec<_>>()
            }),
        ),
        (
            "Parallelized over ImpVec using orx_parallel",
            Box::new(move || {
                let imp_vec: ImpVec<_> = (0..args.len as usize).collect();

                imp_vec
                    .into_par() // replace iter (into_iter) with par (into_par) to parallelize !
                    .filter(|x| *x % 3 != 0)
                    .map(|x| x + fibonacci(x % 40))
                    .filter(|x| x % 2 == 0)
                    .map(|x| x.to_string())
                    .collect::<Vec<_>>()
            }),
        ),
    ];

    timed_collect_all(
        "benchmark_parallelization",
        args.num_repetitions,
        &expected_output,
        &computations,
    );
}