Struct SystemGroup

Source

pub struct SystemGroup(/* private fields */);

Expand description

A built-in group, e.g. MPI_GROUP_EMPTY

§Standard section(s)

6.2.1

Implementations§

Source §

impl SystemGroup

Source

pub fn empty() -> SystemGroup

An empty group

Examples found in repository ?

examples/group.rs (line 32)

8fn main() {
9    let universe = mpi::initialize().unwrap();
10    let world = universe.world();
11
12    let g = world.group();
13    // Group accessors and Communicator accessors agree
14    assert_eq!(world.size(), g.size());
15    assert_eq!(world.rank(), g.rank().unwrap());
16
17    // g == g
18    assert_eq!(GroupRelation::Identical, g.compare(&g));
19
20    let h = world.group();
21    // h == g
22    assert_eq!(GroupRelation::Identical, g.compare(&h));
23
24    let i = g.union(&h);
25    // g union h == g union g == g
26    assert_eq!(GroupRelation::Identical, g.compare(&i));
27
28    let empty = g.difference(&h);
29    // g difference h == g difference g = empty Group
30    assert_eq!(
31        GroupRelation::Identical,
32        SystemGroup::empty().compare(&empty)
33    );
34    assert_eq!(0, empty.size());
35
36    // g intersection empty == empty Group
37    assert_eq!(0, g.intersection(&empty).size());
38
39    let first_half: Vec<Rank> = (0..g.size() / 2).collect();
40
41    // f and s are first and second half of g
42    let f = g.include(&first_half[..]);
43    let s = g.exclude(&first_half[..]);
44    // f != s
45    assert_eq!(GroupRelation::Unequal, f.compare(&s));
46
47    // g intersection f == f
48    let f_ = g.intersection(&f);
49    assert_eq!(GroupRelation::Identical, f.compare(&f_));
50    // g intersection s == s
51    let s_ = g.intersection(&s);
52    assert_eq!(GroupRelation::Identical, s.compare(&s_));
53
54    // g difference s == f
55    let f__ = g.difference(&s);
56    assert_eq!(GroupRelation::Identical, f.compare(&f__));
57    // g difference f == s
58    let s__ = g.difference(&f);
59    assert_eq!(GroupRelation::Identical, s.compare(&s__));
60
61    // f union s == g
62    let fs = f.union(&s);
63    assert_eq!(GroupRelation::Identical, g.compare(&fs));
64
65    // f intersection s == empty Group
66    let fs = f.intersection(&s);
67    assert_eq!(GroupRelation::Identical, empty.compare(&fs));
68
69    // rank is either in f or in s
70    assert!(
71        (f.rank().is_some() && s.rank().is_none()) ^ (f.rank().is_none() && s.rank().is_some())
72    );
73
74    // inverting rank mappings
75    let rev: Vec<Rank> = (0..g.size()).rev().collect();
76    let r = g.include(&rev[..]);
77    assert_eq!(
78        Some(rev[g.rank().unwrap() as usize]),
79        r.translate_rank(g.rank().unwrap(), &g)
80    );
81}

More examples

Hide additional examples

examples/split.rs (line 23)

7fn main() {
8    let universe = mpi::initialize().unwrap();
9    let world = universe.world();
10
11    let odd = (0..world.size()).filter(|x| x % 2 != 0).collect::<Vec<_>>();
12    let odd_group = world.group().include(&odd[..]);
13    let even_group = world.group().difference(&odd_group);
14    assert!(
15        (world.rank() % 2 == 0 && even_group.rank().is_some() && odd_group.rank().is_none())
16            || (even_group.rank().is_none() && odd_group.rank().is_some())
17    );
18    let my_group = if odd_group.rank().is_some() {
19        &odd_group
20    } else {
21        &even_group
22    };
23    let empty_group = SystemGroup::empty();
24
25    let oddness_comm = world.split_by_subgroup_collective(my_group);
26    assert!(oddness_comm.is_some());
27    let oddness_comm = oddness_comm.unwrap();
28    assert_eq!(
29        GroupRelation::Identical,
30        oddness_comm.group().compare(my_group)
31    );
32
33    let odd_comm = if odd_group.rank().is_some() {
34        world.split_by_subgroup_collective(&odd_group)
35    } else {
36        world.split_by_subgroup_collective(&empty_group)
37    };
38    if odd_group.rank().is_some() {
39        assert!(odd_comm.is_some());
40        let odd_comm = odd_comm.unwrap();
41        assert_eq!(
42            GroupRelation::Identical,
43            odd_comm.group().compare(&odd_group)
44        );
45    } else {
46        assert!(odd_comm.is_none());
47    }
48
49    #[cfg(not(msmpi))]
50    {
51        if even_group.rank().is_some() {
52            let even_comm = world.split_by_subgroup(&even_group);
53            assert!(even_comm.is_some());
54            let even_comm = even_comm.unwrap();
55            assert_eq!(
56                GroupRelation::Identical,
57                even_comm.group().compare(&even_group)
58            );
59
60            let no_comm = world.split_by_subgroup(&odd_group);
61            assert!(no_comm.is_none());
62        }
63    }
64
65    let oddness_comm = world.split_by_color(Color::with_value(world.rank() % 2));
66    assert!(oddness_comm.is_some());
67    let oddness_comm = oddness_comm.unwrap();
68    assert_eq!(
69        GroupRelation::Identical,
70        oddness_comm.group().compare(my_group)
71    );
72
73    let odd_comm = world.split_by_color(if world.rank() % 2 != 0 {
74        Color::with_value(0)
75    } else {
76        Color::undefined()
77    });
78    if world.rank() % 2 != 0 {
79        assert!(odd_comm.is_some());
80        let odd_comm = odd_comm.unwrap();
81        assert_eq!(
82            GroupRelation::Identical,
83            odd_comm.group().compare(&odd_group)
84        );
85    } else {
86        assert!(odd_comm.is_none());
87    }
88}