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 31)

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

More examples

Hide additional examples

examples/split.rs (line 22)

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