mpi_fork_fnsp::topology

Trait Group

Source 
pub trait Group: AsRaw<Raw = MPI_Group> {
    // Provided methods
    fn union<G>(&self, other: &G) -> UserGroup
       where G: Group { ... }
    fn intersection<G>(&self, other: &G) -> UserGroup
       where G: Group { ... }
    fn difference<G>(&self, other: &G) -> UserGroup
       where G: Group { ... }
    fn include(&self, ranks: &[Rank]) -> UserGroup { ... }
    fn exclude(&self, ranks: &[Rank]) -> UserGroup { ... }
    fn size(&self) -> Rank { ... }
    fn rank(&self) -> Option<Rank> { ... }
    fn translate_rank<G>(&self, rank: Rank, other: &G) -> Option<Rank>
       where G: Group { ... }
    fn translate_ranks<G>(&self, ranks: &[Rank], other: &G) -> Vec<Option<Rank>>
       where G: Group { ... }
    fn compare<G>(&self, other: &G) -> GroupRelation
       where G: Group { ... }
}
Expand description

Groups are collections of parallel processes

Provided Methods§

Source

fn union<G>(&self, other: &G) -> UserGroup
where G: Group,

Group union

Constructs a new group that contains all members of the first group followed by all members of the second group that are not also members of the first group.

§Standard section(s)

6.3.2

Examples found in repository?
examples/group.rs (line 24)
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}
Source

fn intersection<G>(&self, other: &G) -> UserGroup
where G: Group,

Group intersection

Constructs a new group that contains all processes that are members of both the first and second group in the order they have in the first group.

§Standard section(s)

6.3.2

Examples found in repository?
examples/group.rs (line 37)
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}
Source

fn difference<G>(&self, other: &G) -> UserGroup
where G: Group,

Group difference

Constructs a new group that contains all members of the first group that are not also members of the second group in the order they have in the first group.

§Standard section(s)

6.3.2

Examples found in repository?
examples/group.rs (line 28)
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 13)
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}
Source

fn include(&self, ranks: &[Rank]) -> UserGroup

Subgroup including specified ranks

Constructs a new group where the process with rank ranks[i] in the old group has rank i in the new group.

§Standard section(s)

6.3.2

Examples found in repository?
examples/group.rs (line 42)
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 12)
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}
Source

fn exclude(&self, ranks: &[Rank]) -> UserGroup

Subgroup including specified ranks

Constructs a new group containing those processes from the old group that are not mentioned in ranks.

§Standard section(s)

6.3.2

Examples found in repository?
examples/group.rs (line 43)
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}
Source

fn size(&self) -> Rank

Number of processes in the group.

§Standard section(s)

6.3.1

Examples found in repository?
examples/group.rs (line 14)
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}
Source

fn rank(&self) -> Option<Rank>

Rank of this process within the group.

§Standard section(s)

6.3.1

Examples found in repository?
examples/group.rs (line 15)
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 15)
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}
Source

fn translate_rank<G>(&self, rank: Rank, other: &G) -> Option<Rank>
where G: Group,

Find the rank in group other' of the process that has rank rank` in this group.

If the process is not a member of the other group, returns None.

§Standard section(s)

6.3.1

Examples found in repository?
examples/group.rs (line 79)
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}
Source

fn translate_ranks<G>(&self, ranks: &[Rank], other: &G) -> Vec<Option<Rank>>
where G: Group,

Find the ranks in group other' of the processes that have ranks ranks` in this group.

If a process is not a member of the other group, returns None.

§Standard section(s)

6.3.1

Source

fn compare<G>(&self, other: &G) -> GroupRelation
where G: Group,

Compare two groups.

§Standard section(s)

6.3.1

Examples found in repository?
examples/group.rs (line 18)
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 30)
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}

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors§