mpi 0.6.0

Message Passing Interface bindings for Rust
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

/// Example using different types of requests with a request collection.

#[cfg(msmpi)]
fn main() {}

#[cfg(not(msmpi))]
fn main() {
    use mpi::traits::*;

    const COUNT: usize = 128;

    let universe = mpi::initialize().unwrap();
    let world = universe.world();

    // Try wait_any()
    mpi::request::multiple_scope(COUNT, |_, coll| {
        for _ in 0..COUNT {
            let req = world.immediate_barrier();
            coll.add(req);
        }
        let mut finished = 0;
        while coll.incomplete() > 0 {
            coll.wait_any().unwrap();
            finished += 1;
            assert_eq!(coll.incomplete(), COUNT - finished);
        }
    });

    // Try wait_some()
    mpi::request::multiple_scope(COUNT, |_, coll| {
        for _ in 0..COUNT {
            let req = world.immediate_barrier();
            coll.add(req);
        }
        let mut result = vec![];
        let mut finished = 0;
        while coll.incomplete() > 0 {
            coll.wait_some(&mut result);
            finished += result.len();
            assert_eq!(coll.incomplete(), COUNT - finished);
        }
    });

    // Try wait_all()
    mpi::request::multiple_scope(COUNT, |_, coll| {
        for _ in 0..COUNT {
            let req = world.immediate_barrier();
            coll.add(req);
        }
        let mut result = vec![];
        coll.wait_all(&mut result);
        assert_eq!(result.len(), COUNT);
    });

    // Try test_any()
    mpi::request::multiple_scope(COUNT, |_, coll| {
        for _ in 0..COUNT {
            let req = world.immediate_barrier();
            coll.add(req);
        }
        let mut finished = 0;
        while coll.incomplete() > 0 {
            if coll.test_any().is_some() {
                finished += 1;
            }
            assert_eq!(coll.incomplete(), COUNT - finished);
        }
        assert_eq!(finished, COUNT);
    });

    // Try test_some()
    mpi::request::multiple_scope(COUNT, |_, coll| {
        for _ in 0..COUNT {
            let req = world.immediate_barrier();
            coll.add(req);
        }
        let mut result = vec![];
        let mut finished = 0;
        while coll.incomplete() > 0 {
            coll.test_some(&mut result);
            finished += result.len();
            assert_eq!(coll.incomplete(), COUNT - finished);
        }
        assert_eq!(finished, COUNT);
    });

    // Try test_all()
    mpi::request::multiple_scope(COUNT, |_, coll| {
        for _ in 0..COUNT {
            let req = world.immediate_barrier();
            coll.add(req);
        }
        let mut result = vec![];
        while coll.incomplete() > 0 {
            if coll.test_all(&mut result) {
                assert_eq!(coll.incomplete(), 0);
            }
        }
        assert_eq!(result.len(), COUNT);
    });
}