Struct GraphCommunicator 

pub struct GraphCommunicator { /* private fields */ }

A communicator carrying a general graph topology (MPI_Graph_create).

Implementations

impl GraphCommunicator

pub fn num_nodes(&self) -> Count

Total number of nodes in the graph.

pub fn num_edges(&self) -> Count

Total number of (directed) edges in the graph.

pub fn neighbor_count(&self, rank: Rank) -> Count

The number of neighbours of rank (MPI_Graph_neighbors_count).

Examples found in repository

examples/topo_inter.rs (line 25)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let rank = world.rank();
    let size = world.size();

    // ---- graph topology: a ring, node i adjacent to i-1 and i+1 ----
    if size >= 2 {
        let mut index = Vec::new();
        let mut edges = Vec::new();
        for i in 0..size {
            edges.push((i - 1 + size) % size);
            edges.push((i + 1) % size);
            index.push(2 * (i + 1));
        }
        let g = world
            .create_graph_communicator(&index, &edges)
            .expect("graph create returned None");
        let expected = vec![(rank - 1 + size) % size, (rank + 1) % size];
        assert_eq!(g.my_neighbors(), expected, "graph neighbours mismatch");
        assert_eq!(g.neighbor_count(rank), 2);
        // Neighbourhood all-gather: each neighbour contributes its own rank.
        let mut ng = vec![-1i32; 2];
        g.neighbor_all_gather_into(&rank, &mut ng[..]);
        assert_eq!(ng, expected, "neighbor_all_gather mismatch");
        g.barrier();
    }

    // ---- distributed-graph adjacent: directed ring (recv prev, send next) ----
    if size >= 2 {
        let prev = (rank - 1 + size) % size;
        let next = (rank + 1) % size;
        let dg = world.create_dist_graph_adjacent(&[prev], &[next]);
        assert_eq!(dg.in_degree(), 1, "dist-graph in-degree");
        assert_eq!(dg.out_degree(), 1, "dist-graph out-degree");
        let mut r = vec![-1i32; 1];
        dg.neighbor_all_gather_into(&rank, &mut r[..]);
        assert_eq!(r, vec![prev], "dist-graph neighbor mismatch");
        dg.barrier();
    }

    // ---- inter-communicator: split world into two halves ----
    if size >= 2 {
        let half = size / 2;
        let in_a = rank < half;
        let inter = world.split_intercommunicator(in_a);
        assert_eq!(
            inter.local_size() + inter.remote_size(),
            size,
            "intercomm size mismatch"
        );

        // Leaders of the two groups exchange their world ranks across the
        // inter-communicator.
        if inter.rank() == 0 {
            if in_a {
                inter.process_at_rank(0).send(&rank);
                let (peer, _): (i32, _) = inter.process_at_rank(0).receive();
                assert_eq!(peer, half, "intercomm exchange mismatch (A)");
            } else {
                let (peer, _): (i32, _) = inter.process_at_rank(0).receive();
                assert_eq!(peer, 0, "intercomm exchange mismatch (B)");
                inter.process_at_rank(0).send(&rank);
            }
        }

        // Merge back into one intra-communicator spanning everyone.
        let merged = inter.merge();
        assert_eq!(merged.size(), size, "merge size mismatch");
        merged.barrier();
    }

    world.barrier();
    if rank == 0 {
        println!("TOPO/INTER PASS: graph + inter-communicator verified on {size} ranks.");
    }
}

pub fn neighbors(&self, rank: Rank) -> Vec<Rank>

The neighbours of rank (MPI_Graph_neighbors).

pub fn my_neighbors(&self) -> Vec<Rank>

This process’s neighbours.

Examples found in repository

examples/topo_inter.rs (line 24)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let rank = world.rank();
    let size = world.size();

    // ---- graph topology: a ring, node i adjacent to i-1 and i+1 ----
    if size >= 2 {
        let mut index = Vec::new();
        let mut edges = Vec::new();
        for i in 0..size {
            edges.push((i - 1 + size) % size);
            edges.push((i + 1) % size);
            index.push(2 * (i + 1));
        }
        let g = world
            .create_graph_communicator(&index, &edges)
            .expect("graph create returned None");
        let expected = vec![(rank - 1 + size) % size, (rank + 1) % size];
        assert_eq!(g.my_neighbors(), expected, "graph neighbours mismatch");
        assert_eq!(g.neighbor_count(rank), 2);
        // Neighbourhood all-gather: each neighbour contributes its own rank.
        let mut ng = vec![-1i32; 2];
        g.neighbor_all_gather_into(&rank, &mut ng[..]);
        assert_eq!(ng, expected, "neighbor_all_gather mismatch");
        g.barrier();
    }

    // ---- distributed-graph adjacent: directed ring (recv prev, send next) ----
    if size >= 2 {
        let prev = (rank - 1 + size) % size;
        let next = (rank + 1) % size;
        let dg = world.create_dist_graph_adjacent(&[prev], &[next]);
        assert_eq!(dg.in_degree(), 1, "dist-graph in-degree");
        assert_eq!(dg.out_degree(), 1, "dist-graph out-degree");
        let mut r = vec![-1i32; 1];
        dg.neighbor_all_gather_into(&rank, &mut r[..]);
        assert_eq!(r, vec![prev], "dist-graph neighbor mismatch");
        dg.barrier();
    }

    // ---- inter-communicator: split world into two halves ----
    if size >= 2 {
        let half = size / 2;
        let in_a = rank < half;
        let inter = world.split_intercommunicator(in_a);
        assert_eq!(
            inter.local_size() + inter.remote_size(),
            size,
            "intercomm size mismatch"
        );

        // Leaders of the two groups exchange their world ranks across the
        // inter-communicator.
        if inter.rank() == 0 {
            if in_a {
                inter.process_at_rank(0).send(&rank);
                let (peer, _): (i32, _) = inter.process_at_rank(0).receive();
                assert_eq!(peer, half, "intercomm exchange mismatch (A)");
            } else {
                let (peer, _): (i32, _) = inter.process_at_rank(0).receive();
                assert_eq!(peer, 0, "intercomm exchange mismatch (B)");
                inter.process_at_rank(0).send(&rank);
            }
        }

        // Merge back into one intra-communicator spanning everyone.
        let merged = inter.merge();
        assert_eq!(merged.size(), size, "merge size mismatch");
        merged.barrier();
    }

    world.barrier();
    if rank == 0 {
        println!("TOPO/INTER PASS: graph + inter-communicator verified on {size} ranks.");
    }
}

pub fn neighbor_all_gather_into<S, R>(&self, sendbuf: &S, recvbuf: &mut R)

where S: Buffer + ?Sized, R: BufferMut + ?Sized,

Gather each rank’s sendbuf from all of its neighbours (MPI_Neighbor_allgather). recvbuf holds one block per neighbour, in neighbour order.

Examples found in repository

examples/topo_inter.rs (line 28)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let rank = world.rank();
    let size = world.size();

    // ---- graph topology: a ring, node i adjacent to i-1 and i+1 ----
    if size >= 2 {
        let mut index = Vec::new();
        let mut edges = Vec::new();
        for i in 0..size {
            edges.push((i - 1 + size) % size);
            edges.push((i + 1) % size);
            index.push(2 * (i + 1));
        }
        let g = world
            .create_graph_communicator(&index, &edges)
            .expect("graph create returned None");
        let expected = vec![(rank - 1 + size) % size, (rank + 1) % size];
        assert_eq!(g.my_neighbors(), expected, "graph neighbours mismatch");
        assert_eq!(g.neighbor_count(rank), 2);
        // Neighbourhood all-gather: each neighbour contributes its own rank.
        let mut ng = vec![-1i32; 2];
        g.neighbor_all_gather_into(&rank, &mut ng[..]);
        assert_eq!(ng, expected, "neighbor_all_gather mismatch");
        g.barrier();
    }

    // ---- distributed-graph adjacent: directed ring (recv prev, send next) ----
    if size >= 2 {
        let prev = (rank - 1 + size) % size;
        let next = (rank + 1) % size;
        let dg = world.create_dist_graph_adjacent(&[prev], &[next]);
        assert_eq!(dg.in_degree(), 1, "dist-graph in-degree");
        assert_eq!(dg.out_degree(), 1, "dist-graph out-degree");
        let mut r = vec![-1i32; 1];
        dg.neighbor_all_gather_into(&rank, &mut r[..]);
        assert_eq!(r, vec![prev], "dist-graph neighbor mismatch");
        dg.barrier();
    }

    // ---- inter-communicator: split world into two halves ----
    if size >= 2 {
        let half = size / 2;
        let in_a = rank < half;
        let inter = world.split_intercommunicator(in_a);
        assert_eq!(
            inter.local_size() + inter.remote_size(),
            size,
            "intercomm size mismatch"
        );

        // Leaders of the two groups exchange their world ranks across the
        // inter-communicator.
        if inter.rank() == 0 {
            if in_a {
                inter.process_at_rank(0).send(&rank);
                let (peer, _): (i32, _) = inter.process_at_rank(0).receive();
                assert_eq!(peer, half, "intercomm exchange mismatch (A)");
            } else {
                let (peer, _): (i32, _) = inter.process_at_rank(0).receive();
                assert_eq!(peer, 0, "intercomm exchange mismatch (B)");
                inter.process_at_rank(0).send(&rank);
            }
        }

        // Merge back into one intra-communicator spanning everyone.
        let merged = inter.merge();
        assert_eq!(merged.size(), size, "merge size mismatch");
        merged.barrier();
    }

    world.barrier();
    if rank == 0 {
        println!("TOPO/INTER PASS: graph + inter-communicator verified on {size} ranks.");
    }
}

pub fn neighbor_all_to_all_into<S, R>(&self, sendbuf: &S, recvbuf: &mut R)

where S: Buffer + ?Sized, R: BufferMut + ?Sized,

Exchange a distinct block with each neighbour (MPI_Neighbor_alltoall). sendbuf and recvbuf hold one block per neighbour, in neighbour order.

Trait Implementations

impl Clone for GraphCommunicator

fn clone(&self) -> GraphCommunicator

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Communicator for GraphCommunicator

fn size(&self) -> Rank

Number of processes in the communicator (MPI_Comm_size).

fn rank(&self) -> Rank

This process’s rank in the communicator (MPI_Comm_rank).

fn target_size(&self) -> Rank

Number of processes on the remote side (equals Communicator::size for an intra-communicator).

fn process_at_rank(&self, r: Rank) -> Process<'_>

A handle to the process with the given rank.

fn this_process(&self) -> Process<'_>

A handle to this process.

fn any_process(&self) -> AnyProcess<'_>

A handle matching any source (MPI_ANY_SOURCE), for receives.

fn group(&self) -> Group

The group underlying this communicator (MPI_Comm_group).

fn compare(&self, other: &dyn Communicator) -> CommunicatorRelation

Compare this communicator to other (MPI_Comm_compare).

fn duplicate(&self) -> SimpleCommunicator

Duplicate the communicator with a fresh context (MPI_Comm_dup). Collective over all members.

fn split_by_color(&self, color: Color) -> Option<SimpleCommunicator>

Split the communicator by colour (MPI_Comm_split). Collective.

fn split_by_color_with_key( &self, color: Color, key: Key, ) -> Option<SimpleCommunicator>

Split by colour, ordering new ranks by key then old rank (MPI_Comm_split). Collective.

fn split_by_subgroup(&self, group: &Group) -> Option<SimpleCommunicator>

Split by an explicit subgroup (MPI_Comm_create style). Collective; returns None for processes not in group.

fn abort(&self, errorcode: i32) -> !

Abort the whole job with an exit code (MPI_Abort). Notifies every peer so the entire job exits rather than leaving ranks blocked.

fn set_name(&self, name: &str)

Set the communicator’s name (MPI_Comm_set_name).

fn get_name(&self) -> String

Get the communicator’s name (MPI_Comm_get_name).

fn pack_size(&self, incount: Count, dt: DatatypeRef) -> Count

Number of bytes needed to pack incount elements of datatype dt (MPI_Pack_size).

fn pack<Buf: Buffer + ?Sized>(&self, inbuf: &Buf) -> Vec<u8>

where Self: Sized,

Pack a buffer into a freshly allocated byte vector (MPI_Pack). Since this implementation uses contiguous native layouts, packing is a copy.

fn pack_into<Buf: Buffer + ?Sized>( &self, inbuf: &Buf, outbuf: &mut [u8], position: Count, ) -> Count

where Self: Sized,

Pack a buffer into outbuf starting at byte offset position, returning the new position (MPI_Pack).

unsafe fn unpack_into<Buf: BufferMut + ?Sized>( &self, inbuf: &[u8], outbuf: &mut Buf, position: Count, ) -> Count

where Self: Sized,

Unpack from inbuf starting at byte offset position into outbuf, returning the new position (MPI_Unpack).

fn create_graph_communicator( &self, index: &[Count], edges: &[Count], ) -> Option<GraphCommunicator>

Create a graph topology communicator (MPI_Graph_create).

fn create_dist_graph_adjacent( &self, sources: &[Rank], destinations: &[Rank], ) -> DistGraphCommunicator

Create a distributed-graph topology where this rank receives from sources and sends to destinations (MPI_Dist_graph_create_adjacent). Collective; each rank supplies its own adjacency.

fn split_intercommunicator(&self, in_group_a: bool) -> InterCommunicator

Collectively split this communicator into an inter-communicator between two disjoint groups. Ranks passing true form one group (“A”); the rest form the other. Each rank’s InterCommunicator has the other group as its remote group (MPI_Intercomm_create-style, collective).

fn create_cartesian_communicator( &self, dims: &[Count], periods: &[bool], _reorder: bool, ) -> Option<CartesianCommunicator>

Create a Cartesian topology communicator (MPI_Cart_create).

fn parent(&self) -> Option<InterCommunicator>

If this process was created by crate::collective::Root::spawn, return the inter-communicator to the parent group (MPI_Comm_get_parent). The local group is this world; the remote group is the spawner.