orx-parallel 3.4.0

High performance, configurable and expressive parallel computation library.
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use crate::{test_utils::*, *};
use alloc::format;
use alloc::string::{String, ToString};
use alloc::vec::Vec;
use orx_concurrent_vec::ConcurrentVec;
use test_case::test_matrix;

fn input<O: FromIterator<String>>(n: usize) -> O {
    let elem = |x: usize| (x + 10).to_string();
    (0..n).map(elem).collect()
}

fn sorted(mut x: Vec<String>) -> Vec<String> {
    x.sort();
    x
}

#[test_matrix(N, NT, CHUNK)]
fn for_each_empty(n: &[usize], nt: &[usize], chunk: &[usize]) {
    let test = |n, nt, chunk| {
        let input = || input::<Vec<_>>(n);

        let par = input().into_par().num_threads(nt).chunk_size(chunk);
        let vec = ConcurrentVec::new();
        par.for_each(|x| {
            _ = vec.push(x);
        });

        assert_eq!(sorted(vec.to_vec()), sorted(input()));
    };
    test_n_nt_chunk(n, nt, chunk, test);
}

#[test_matrix(N, NT, CHUNK)]
fn for_each_map(n: &[usize], nt: &[usize], chunk: &[usize]) {
    let test = |n, nt, chunk| {
        let input = || input::<Vec<_>>(n);
        let map = |x| format!("{}!", x);

        let par = input().into_par().num_threads(nt).chunk_size(chunk);
        let par = par.map(&map);
        let vec = ConcurrentVec::new();
        par.for_each(|x| {
            _ = vec.push(x);
        });

        assert_eq!(
            sorted(vec.to_vec()),
            sorted(input().into_iter().map(map).collect())
        );
    };
    test_n_nt_chunk(n, nt, chunk, test);
}

#[test_matrix(N, NT, CHUNK)]
fn for_each_xap_flat_map(n: &[usize], nt: &[usize], chunk: &[usize]) {
    let test = |n, nt, chunk| {
        let input = || input::<Vec<_>>(n);
        let flat_map = |x: String| x.chars().map(|x| x.to_string()).collect::<Vec<_>>();

        let par = input().into_par().num_threads(nt).chunk_size(chunk);
        let par = par.flat_map(flat_map);
        let vec = ConcurrentVec::new();
        par.for_each(|x| {
            _ = vec.push(x);
        });

        assert_eq!(
            sorted(vec.to_vec()),
            sorted(input().into_iter().flat_map(flat_map).collect())
        );
    };
    test_n_nt_chunk(n, nt, chunk, test);
}

#[test_matrix(N, NT, CHUNK)]
fn for_each_xap_filter_map(n: &[usize], nt: &[usize], chunk: &[usize]) {
    let test = |n, nt, chunk| {
        let input = || input::<Vec<_>>(n);
        let filter_map = |x: String| x.starts_with('3').then_some(x);

        let par = input().into_par().num_threads(nt).chunk_size(chunk);
        let par = par.filter_map(filter_map);
        let vec = ConcurrentVec::new();
        par.for_each(|x| {
            _ = vec.push(x);
        });

        assert_eq!(
            sorted(vec.to_vec()),
            sorted(input().into_iter().filter_map(filter_map).collect())
        );
    };
    test_n_nt_chunk(n, nt, chunk, test);
}

#[test_matrix(N, NT, CHUNK)]
fn for_each_xap_filter_xap(n: &[usize], nt: &[usize], chunk: &[usize]) {
    let test = |n, nt, chunk| {
        let input = || input::<Vec<_>>(n);
        let filter_map = |x: String| x.starts_with('3').then_some(x);
        let filter = |x: &String| x.ends_with('3');
        let flat_map = |x: String| x.chars().map(|x| x.to_string()).collect::<Vec<_>>();

        let par = input().into_par().num_threads(nt).chunk_size(chunk);
        let par = par.filter_map(filter_map).filter(filter).flat_map(flat_map);
        let vec = ConcurrentVec::new();
        par.for_each(|x| {
            _ = vec.push(x);
        });

        assert_eq!(
            sorted(vec.to_vec()),
            sorted(
                input()
                    .into_iter()
                    .filter_map(filter_map)
                    .filter(filter)
                    .flat_map(flat_map)
                    .collect()
            )
        );
    };
    test_n_nt_chunk(n, nt, chunk, test);
}