simple_parallel 0.3.0

Straight-forward functions and types for basic data parallel operations, including parallel maps, for loops and thread pools. 
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

extern crate simple_parallel;
extern crate crossbeam;

use std::sync::Mutex;

fn eq<I, J>(mut x: I, mut y: J) -> bool
    where I: Iterator, J: Iterator<Item = I::Item>, I::Item: PartialEq
{
    loop {
        match (x.next(), y.next()) {
            (None, None) => return true,
            (Some(ref x), Some(ref y)) if x == y => continue,
            _ => return false
        }
    }
}

// with this many elements, its (hopefully) likely that the
// threads won't execute sequentially.
const N: usize = 1000;
const M: usize = 100;

#[test]
fn unordered_map_probabilistic_out_of_ordering() {
    crossbeam::scope(|scope| {
        let iter = simple_parallel::unordered_map(scope, 0..N, |_| {});

        // see if there are any elements where the order they come out of
        // the original iterator is different to the order in which they
        // are yielded here.
        assert!(!eq(iter.map(|t| t.0), 0..N));
    });
}

#[test]
fn map_in_order() {
    crossbeam::scope(|scope| {
        let iter = simple_parallel::map(scope, 0..N, |i| i);

        assert!(eq(iter, 0..N));
    });
}

#[test]
fn unordered_map_delays() {
    let finished = Mutex::new(0);
    crossbeam::scope(|scope| {
        let iter = simple_parallel::unordered_map(scope, 0..M, |_| {
            *finished.lock().unwrap() += 1;
        });
        ::std::mem::forget(iter);
    });

    assert_eq!(*finished.lock().unwrap(), M);
}

#[test]
fn map_delays() {
    let finished = Mutex::new(0);
    crossbeam::scope(|scope| {
        let iter = simple_parallel::map(scope, 0..M, |_| {
            *finished.lock().unwrap() += 1;
        });
        ::std::mem::forget(iter);
    });

    assert_eq!(*finished.lock().unwrap(), M);
}

#[test]
fn pool_unordered() {
    crossbeam::scope(|scope| {
        let mut pool = simple_parallel::Pool::new(8);

        let iter = pool.unordered_map(scope, 0..N, |_| {});

        // see if there are any elements where the order they come out of
        // the original iterator is different to the order in which they
        // are yielded here.
        assert!(!eq(iter.map(|t| t.0), 0..N));
    });
}

#[test]
fn pool_map_in_order() {
    crossbeam::scope(|scope| {
        let mut pool = simple_parallel::Pool::new(8);

        let iter = pool.map(scope, 0..N, |i| i);

        assert!(eq(iter, 0..N));
    });
}

#[test]
fn pool_unordered_map_delays() {
    let mut pool = simple_parallel::Pool::new(8);
    let finished = Mutex::new(0);
    crossbeam::scope(|scope| {
        let iter = pool.unordered_map(scope, 0..M, |_| {
            *finished.lock().unwrap() += 1;
        });
        ::std::mem::forget(iter);
    });

    assert_eq!(*finished.lock().unwrap(), M);
}

#[test]
fn pool_map_delays() {
    let mut pool = simple_parallel::Pool::new(8);
    let finished = Mutex::new(0);
    crossbeam::scope(|scope| {
        let iter = pool.map(scope, 0..M, |_| {
            *finished.lock().unwrap() += 1;
        });
        ::std::mem::forget(iter);
    });

    assert_eq!(*finished.lock().unwrap(), M);
}