Trait Root

pub trait Root: AsCommunicator {
    // Required method
    fn root_rank(&self) -> Rank;

    // Provided methods
    fn broadcast_into<Buf>(&self, buffer: &mut Buf)
       where Buf: BufferMut + ?Sized { ... }
    fn gather_into<S>(&self, sendbuf: &S)
       where S: Buffer + ?Sized { ... }
    fn gather_into_root<S, R>(&self, sendbuf: &S, recvbuf: &mut R)
       where S: Buffer + ?Sized,
             R: BufferMut + ?Sized { ... }
    fn gather_varcount_into<S>(&self, sendbuf: &S)
       where S: Buffer + ?Sized { ... }
    fn gather_varcount_into_root<S, R>(&self, sendbuf: &S, recvbuf: &mut R)
       where S: Buffer + ?Sized,
             R: PartitionedBufferMut + ?Sized { ... }
    fn scatter_into<R>(&self, recvbuf: &mut R)
       where R: BufferMut + ?Sized { ... }
    fn scatter_into_root<S, R>(&self, sendbuf: &S, recvbuf: &mut R)
       where S: Buffer + ?Sized,
             R: BufferMut + ?Sized { ... }
    fn scatter_varcount_into<R>(&self, recvbuf: &mut R)
       where R: BufferMut + ?Sized { ... }
    fn scatter_varcount_into_root<S, R>(&self, sendbuf: &S, recvbuf: &mut R)
       where S: PartitionedBuffer + ?Sized,
             R: BufferMut + ?Sized { ... }
    fn reduce_into<S, O>(&self, sendbuf: &S, op: O)
       where S: Buffer + ?Sized,
             O: Operation { ... }
    fn reduce_into_root<S, R, O>(&self, sendbuf: &S, recvbuf: &mut R, op: O)
       where S: Buffer + ?Sized,
             R: BufferMut + ?Sized,
             O: Operation { ... }
    fn immediate_broadcast_into<'a, Sc, Buf>(
        &self,
        scope: Sc,
        buf: &'a mut Buf,
    ) -> Request<'a, Sc>
       where Buf: 'a + BufferMut + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_gather_into<'a, Sc, S>(
        &self,
        scope: Sc,
        sendbuf: &'a S,
    ) -> Request<'a, Sc>
       where S: 'a + Buffer + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_gather_into_root<'a, Sc, S, R>(
        &self,
        scope: Sc,
        sendbuf: &'a S,
        recvbuf: &'a mut R,
    ) -> Request<'a, Sc>
       where S: 'a + Buffer + ?Sized,
             R: 'a + BufferMut + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_gather_varcount_into<'a, Sc, S>(
        &self,
        scope: Sc,
        sendbuf: &'a S,
    ) -> Request<'a, Sc>
       where S: 'a + Buffer + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_gather_varcount_into_root<'a, Sc, S, R>(
        &self,
        scope: Sc,
        sendbuf: &'a S,
        recvbuf: &'a mut R,
    ) -> Request<'a, Sc>
       where S: 'a + Buffer + ?Sized,
             R: 'a + PartitionedBufferMut + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_scatter_into<'a, Sc, R>(
        &self,
        scope: Sc,
        recvbuf: &'a mut R,
    ) -> Request<'a, Sc>
       where R: 'a + BufferMut + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_scatter_into_root<'a, Sc, S, R>(
        &self,
        scope: Sc,
        sendbuf: &'a S,
        recvbuf: &'a mut R,
    ) -> Request<'a, Sc>
       where S: 'a + Buffer + ?Sized,
             R: 'a + BufferMut + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_scatter_varcount_into<'a, Sc, R>(
        &self,
        scope: Sc,
        recvbuf: &'a mut R,
    ) -> Request<'a, Sc>
       where R: 'a + BufferMut + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_scatter_varcount_into_root<'a, Sc, S, R>(
        &self,
        scope: Sc,
        sendbuf: &'a S,
        recvbuf: &'a mut R,
    ) -> Request<'a, Sc>
       where S: 'a + PartitionedBuffer + ?Sized,
             R: 'a + BufferMut + ?Sized,
             Sc: Scope<'a> { ... }
    fn immediate_reduce_into<'a, Sc, S, O>(
        &self,
        scope: Sc,
        sendbuf: &'a S,
        op: O,
    ) -> Request<'a, Sc>
       where S: 'a + Buffer + ?Sized,
             O: 'a + Operation,
             Sc: Scope<'a> { ... }
    fn immediate_reduce_into_root<'a, Sc, S, R, O>(
        &self,
        scope: Sc,
        sendbuf: &'a S,
        recvbuf: &'a mut R,
        op: O,
    ) -> Request<'a, Sc>
       where S: 'a + Buffer + ?Sized,
             R: 'a + BufferMut + ?Sized,
             O: 'a + Operation,
             Sc: Scope<'a> { ... }
}

Something that can take the role of ‘root’ in a collective operation.

Many collective operations define a ‘root’ process that takes a special role in the communication. These collective operations are implemented as default methods of this trait.

Required Methods

fn root_rank(&self) -> Rank

Rank of the root process

Provided Methods

fn broadcast_into<Buf>(&self, buffer: &mut Buf)

where Buf: BufferMut + ?Sized,

Broadcast of the contents of a buffer

After the call completes, the Buffer on all processes in the Communicator of the Root &self will contain what it contains on the Root.

Examples

See examples/broadcast.rs

Standard section(s)

5.4

Examples found in repository

examples/structured.rs (line 31)

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

    let root_process = world.process_at_rank(0);

    if world.rank() == 0 {
        root_process.broadcast_into(&mut MyInts([3, 2, 1]));
    } else {
        let mut ints: [i32; 3] = [0, 0, 0];
        root_process.broadcast_into(&mut ints[..]);

        assert_eq!([1, 2, 3], ints);
    }
}

examples/datatype_dup.rs (line 24)

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

    let root_process = world.process_at_rank(0);

    let int_type = i32::equivalent_datatype().dup();

    let mut ints = if world.rank() == 0 {
        [1i32, 2, 3, 4]
    } else {
        [0, 0, 0, 0]
    };

    let mut buffer =
        unsafe { DynBufferMut::from_raw(ints.as_mut_ptr(), ints.count(), int_type.as_ref()) };

    root_process.broadcast_into(&mut buffer);

    assert_eq!([1, 2, 3, 4], ints);
}

examples/complex_datatype.rs (line 67)

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

    let root_process = world.process_at_rank(0);

    let mut data = if world.rank() == 0 {
        ComplexDatatype {
            b: true,
            ints: [1, -2, 3, -4],
            tuple: TupleType([-0.1, 0.1], 7),
        }
    } else {
        ComplexDatatype::default()
    };

    root_process.broadcast_into(&mut data);

    assert_eq!(true, data.b);
    assert_eq!([1, -2, 3, -4], data.ints);
    assert_eq!([-0.1, 0.1], data.tuple.0);
    assert_eq!(7, data.tuple.1);
}

examples/broadcast_complex.rs (line 23)

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

    let root_process = world.process_at_rank(0);

    let mut data = if world.rank() == 0 {
        [
            Complex::<f64>::new(1., -2.),
            Complex::<f64>::new(8., -4.),
            Complex::<f64>::new(3., -9.),
            Complex::<f64>::new(7., -5.),
        ]
    } else {
        [Complex::<f64>::new(0., 0.); 4]
    };

    // root_process.broadcast_into(&mut data);
    root_process.broadcast_into(&mut data[..]);

    assert_eq!(
        data,
        [
            Complex::<f64>::new(1., -2.),
            Complex::<f64>::new(8., -4.),
            Complex::<f64>::new(3., -9.),
            Complex::<f64>::new(7., -5.),
        ]
    );
}

examples/broadcast.rs (line 19)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let root_rank = 0;
    let root_process = world.process_at_rank(root_rank);

    let mut x;
    if world.rank() == root_rank {
        x = 2_u64.pow(10);
        println!("Root broadcasting value: {}.", x);
    } else {
        x = 0_u64;
    }
    root_process.broadcast_into(&mut x);
    println!("Rank {} received value: {}.", world.rank(), x);
    assert_eq!(x, 1024);
    println!();

    let mut a;
    let n = 4;
    if world.rank() == root_rank {
        a = (1..).map(|i| 2_u64.pow(i)).take(n).collect::<Vec<_>>();
        println!("Root broadcasting value: {:?}.", &a[..]);
    } else {
        a = std::iter::repeat(0_u64).take(n).collect::<Vec<_>>();
    }
    root_process.broadcast_into(&mut a[..]);
    println!("Rank {} received value: {:?}.", world.rank(), &a[..]);
    assert_eq!(&a[..], &[2, 4, 8, 16]);
}

examples/readme.rs (line 44)

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

    let next_rank = if rank + 1 < size { rank + 1 } else { 0 };
    let previous_rank = if rank > 0 { rank - 1 } else { size - 1 };

    let msg = vec![rank, 2 * rank, 4 * rank];
    mpi::request::scope(|scope| {
        let _sreq = WaitGuard::from(
            world
                .process_at_rank(next_rank)
                .immediate_send(scope, &msg[..]),
        );

        let (msg, status) = world.any_process().receive_vec();

        println!(
            "Process {} got message {:?}.\nStatus is: {:?}",
            rank, msg, status
        );
        let x = status.source_rank();
        assert_eq!(x, previous_rank);
        assert_eq!(vec![x, 2 * x, 4 * x], msg);

        let root_rank = 0;
        let root_process = world.process_at_rank(root_rank);

        let mut a;
        if world.rank() == root_rank {
            a = vec![2, 4, 8, 16];
            println!("Root broadcasting value: {:?}.", &a[..]);
        } else {
            a = vec![0; 4];
        }
        root_process.broadcast_into(&mut a[..]);
        println!("Rank {} received value: {:?}.", world.rank(), &a[..]);
        assert_eq!(&a[..], &[2, 4, 8, 16]);
    });
}

fn gather_into<S>(&self, sendbuf: &S)

where S: Buffer + ?Sized,

Gather contents of buffers on Root.

After the call completes, the contents of the Buffers on all ranks will be concatenated into the Buffer on Root.

All send Buffers must have the same count of elements.

This function must be called on all non-root processes.

Examples

See examples/gather.rs

Standard section(s)

5.5

Examples found in repository

examples/gather.rs (line 26)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let root_rank = 0;
    let root_process = world.process_at_rank(root_rank);

    let count = world.size() as usize;
    let i = 2_u64.pow(world.rank() as u32 + 1);

    if world.rank() == root_rank {
        let mut a = vec![0u64; count];
        root_process.gather_into_root(&i, &mut a[..]);
        println!("Root gathered sequence: {:?}.", a);
        assert!(a
            .iter()
            .enumerate()
            .all(|(a, &b)| b == 2u64.pow(a as u32 + 1)));
    } else {
        root_process.gather_into(&i);
    }

    let factor = world.rank() as u64 + 1;
    let a = (1_u64..)
        .take(count)
        .map(|x| x * factor)
        .collect::<Vec<_>>();

    if world.rank() == root_rank {
        let mut t = vec![0u64; count * count];
        root_process.gather_into_root(&a[..], &mut t[..]);
        println!("Root gathered table:");
        for r in t.chunks(count) {
            println!("{:?}", r);
        }
        assert!((0_u64..)
            .zip(t.iter())
            .all(|(a, &b)| b == (a / count as u64 + 1) * (a % count as u64 + 1)));
    } else {
        root_process.gather_into(&a[..]);
    }

    let d = UserDatatype::contiguous(count as Count, &u64::equivalent_datatype());
    let sv = unsafe { View::with_count_and_datatype(&a[..], 1, &d) };

    if world.rank() == root_rank {
        let mut t = vec![0u64; count * count];

        {
            let mut rv =
                unsafe { MutView::with_count_and_datatype(&mut t[..], count as Count, &d) };
            root_process.gather_into_root(&sv, &mut rv);
        }

        println!("Root gathered table:");
        for r in t.chunks(count) {
            println!("{:?}", r);
        }
        assert!((0_u64..)
            .zip(t.iter())
            .all(|(a, &b)| b == (a / count as u64 + 1) * (a % count as u64 + 1)));
    } else {
        root_process.gather_into(&sv);
    }
}

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

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

Gather contents of buffers on Root.

After the call completes, the contents of the Buffers on all ranks will be concatenated into the Buffer on Root.

All send Buffers must have the same count of elements.

This function must be called on the root process.

Examples

See examples/gather.rs

Standard section(s)

5.5

Examples found in repository

examples/gather.rs (line 19)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let root_rank = 0;
    let root_process = world.process_at_rank(root_rank);

    let count = world.size() as usize;
    let i = 2_u64.pow(world.rank() as u32 + 1);

    if world.rank() == root_rank {
        let mut a = vec![0u64; count];
        root_process.gather_into_root(&i, &mut a[..]);
        println!("Root gathered sequence: {:?}.", a);
        assert!(a
            .iter()
            .enumerate()
            .all(|(a, &b)| b == 2u64.pow(a as u32 + 1)));
    } else {
        root_process.gather_into(&i);
    }

    let factor = world.rank() as u64 + 1;
    let a = (1_u64..)
        .take(count)
        .map(|x| x * factor)
        .collect::<Vec<_>>();

    if world.rank() == root_rank {
        let mut t = vec![0u64; count * count];
        root_process.gather_into_root(&a[..], &mut t[..]);
        println!("Root gathered table:");
        for r in t.chunks(count) {
            println!("{:?}", r);
        }
        assert!((0_u64..)
            .zip(t.iter())
            .all(|(a, &b)| b == (a / count as u64 + 1) * (a % count as u64 + 1)));
    } else {
        root_process.gather_into(&a[..]);
    }

    let d = UserDatatype::contiguous(count as Count, &u64::equivalent_datatype());
    let sv = unsafe { View::with_count_and_datatype(&a[..], 1, &d) };

    if world.rank() == root_rank {
        let mut t = vec![0u64; count * count];

        {
            let mut rv =
                unsafe { MutView::with_count_and_datatype(&mut t[..], count as Count, &d) };
            root_process.gather_into_root(&sv, &mut rv);
        }

        println!("Root gathered table:");
        for r in t.chunks(count) {
            println!("{:?}", r);
        }
        assert!((0_u64..)
            .zip(t.iter())
            .all(|(a, &b)| b == (a / count as u64 + 1) * (a % count as u64 + 1)));
    } else {
        root_process.gather_into(&sv);
    }
}

fn gather_varcount_into<S>(&self, sendbuf: &S)

where S: Buffer + ?Sized,

Gather contents of buffers on Root.

After the call completes, the contents of the Buffers on all ranks will be concatenated into the Buffer on Root.

The send Buffers may contain different counts of elements on different processes. The distribution of elements in the receive Buffer is specified via Partitioned.

This function must be called on all non-root processes.

Examples

See examples/gather_varcount.rs

Standard section(s)

5.5

Examples found in repository

examples/gather_varcount.rs (line 43)

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

    let rank = world.rank();
    let size = world.size();

    let root_rank = 0;
    let root_process = world.process_at_rank(root_rank);

    let msg: Vec<_> = (0..rank).collect();

    if rank == root_rank {
        let counts: Vec<Count> = (0..size).collect();
        let displs: Vec<Count> = counts
            .iter()
            .scan(0, |acc, &x| {
                let tmp = *acc;
                *acc += x;
                Some(tmp)
            })
            .collect();

        let mut buf = vec![0; (size * (size - 1) / 2) as usize];
        {
            let mut partition = PartitionMut::new(&mut buf[..], counts, &displs[..]);
            root_process.gather_varcount_into_root(&msg[..], &mut partition);
        }

        assert!(buf
            .iter()
            .zip((0..size).flat_map(|r| (0..r)))
            .all(|(&i, j)| i == j));
        println!("{:?}", buf);
    } else {
        root_process.gather_varcount_into(&msg[..]);
    }
}

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

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

Gather contents of buffers on Root.

After the call completes, the contents of the Buffers on all ranks will be concatenated into the Buffer on Root.

The send Buffers may contain different counts of elements on different processes. The distribution of elements in the receive Buffer is specified via Partitioned.

This function must be called on the root process.

Examples

See examples/gather_varcount.rs

Standard section(s)

5.5

Examples found in repository

examples/gather_varcount.rs (line 34)

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

    let rank = world.rank();
    let size = world.size();

    let root_rank = 0;
    let root_process = world.process_at_rank(root_rank);

    let msg: Vec<_> = (0..rank).collect();

    if rank == root_rank {
        let counts: Vec<Count> = (0..size).collect();
        let displs: Vec<Count> = counts
            .iter()
            .scan(0, |acc, &x| {
                let tmp = *acc;
                *acc += x;
                Some(tmp)
            })
            .collect();

        let mut buf = vec![0; (size * (size - 1) / 2) as usize];
        {
            let mut partition = PartitionMut::new(&mut buf[..], counts, &displs[..]);
            root_process.gather_varcount_into_root(&msg[..], &mut partition);
        }

        assert!(buf
            .iter()
            .zip((0..size).flat_map(|r| (0..r)))
            .all(|(&i, j)| i == j));
        println!("{:?}", buf);
    } else {
        root_process.gather_varcount_into(&msg[..]);
    }
}

fn scatter_into<R>(&self, recvbuf: &mut R)

where R: BufferMut + ?Sized,

Scatter contents of a buffer on the root process to all processes.

After the call completes each participating process will have received a part of the send Buffer on the root process.

All send Buffers must have the same count of elements.

This function must be called on all non-root processes.

Examples

See examples/scatter.rs

Standard section(s)

5.6

Examples found in repository

examples/scatter.rs (line 20)

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

    let mut x = 0 as Rank;
    if rank == root_rank {
        let v = (0..size).collect::<Vec<_>>();
        root_process.scatter_into_root(&v[..], &mut x);
    } else {
        root_process.scatter_into(&mut x);
    }
    assert_eq!(x, rank);
}

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

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

Scatter contents of a buffer on the root process to all processes.

After the call completes each participating process will have received a part of the send Buffer on the root process.

All send Buffers must have the same count of elements.

This function must be called on the root process.

Examples

See examples/scatter.rs

Standard section(s)

5.6

Examples found in repository

examples/scatter.rs (line 18)

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

    let mut x = 0 as Rank;
    if rank == root_rank {
        let v = (0..size).collect::<Vec<_>>();
        root_process.scatter_into_root(&v[..], &mut x);
    } else {
        root_process.scatter_into(&mut x);
    }
    assert_eq!(x, rank);
}

fn scatter_varcount_into<R>(&self, recvbuf: &mut R)

where R: BufferMut + ?Sized,

Scatter contents of a buffer on the root process to all processes.

After the call completes each participating process will have received a part of the send Buffer on the root process.

The send Buffer may contain different counts of elements for different processes. The distribution of elements in the send Buffer is specified via Partitioned.

This function must be called on all non-root processes.

Examples

See examples/scatter_varcount.rs

Standard section(s)

5.6

Examples found in repository

examples/scatter_varcount.rs (line 34)

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

    let rank = world.rank();
    let size = world.size();

    let root_rank = 0;
    let root_process = world.process_at_rank(root_rank);

    let mut buf = vec![0; rank as usize];

    if rank == root_rank {
        let msg: Vec<_> = (0..size).flat_map(|i| (0..i)).collect();
        let counts: Vec<Count> = (0..size).collect();
        let displs: Vec<Count> = counts
            .iter()
            .scan(0, |acc, &x| {
                let tmp = *acc;
                *acc += x;
                Some(tmp)
            })
            .collect();
        let partition = Partition::new(&msg[..], counts, &displs[..]);
        root_process.scatter_varcount_into_root(&partition, &mut buf[..]);
    } else {
        root_process.scatter_varcount_into(&mut buf[..]);
    }

    assert!(buf.iter().zip(0..rank).all(|(&i, j)| i == j));
    println!("Process {} got message: {:?}", rank, buf);
}

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

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

Scatter contents of a buffer on the root process to all processes.

After the call completes each participating process will have received a part of the send Buffer on the root process.

The send Buffer may contain different counts of elements for different processes. The distribution of elements in the send Buffer is specified via Partitioned.

This function must be called on the root process.

Examples

See examples/scatter_varcount.rs

Standard section(s)

5.6

Examples found in repository

examples/scatter_varcount.rs (line 32)

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

    let rank = world.rank();
    let size = world.size();

    let root_rank = 0;
    let root_process = world.process_at_rank(root_rank);

    let mut buf = vec![0; rank as usize];

    if rank == root_rank {
        let msg: Vec<_> = (0..size).flat_map(|i| (0..i)).collect();
        let counts: Vec<Count> = (0..size).collect();
        let displs: Vec<Count> = counts
            .iter()
            .scan(0, |acc, &x| {
                let tmp = *acc;
                *acc += x;
                Some(tmp)
            })
            .collect();
        let partition = Partition::new(&msg[..], counts, &displs[..]);
        root_process.scatter_varcount_into_root(&partition, &mut buf[..]);
    } else {
        root_process.scatter_varcount_into(&mut buf[..]);
    }

    assert!(buf.iter().zip(0..rank).all(|(&i, j)| i == j));
    println!("Process {} got message: {:?}", rank, buf);
}

fn reduce_into<S, O>(&self, sendbuf: &S, op: O)

where S: Buffer + ?Sized, O: Operation,

Performs a global reduction under the operation op of the input data in sendbuf and stores the result on the Root process.

This function must be called on all non-root processes.

Examples

See examples/reduce.rs

Standard section(s)

5.9.1

Examples found in repository

examples/reduce.rs (line 85)

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

    if rank == root_rank {
        let mut sum: Rank = 0;
        world
            .process_at_rank(root_rank)
            .reduce_into_root(&rank, &mut sum, SystemOperation::sum());
        assert_eq!(sum, size * (size - 1) / 2);
    } else {
        world
            .process_at_rank(root_rank)
            .reduce_into(&rank, SystemOperation::sum());
    }

    let mut max: Rank = -1;

    world.all_reduce_into(&rank, &mut max, SystemOperation::max());
    assert_eq!(max, size - 1);

    let a: u16 = 0b0000_1111_1111_0000;
    let b: u16 = 0b0011_1100_0011_1100;

    let mut c = b;
    collective::reduce_local_into(&a, &mut c, SystemOperation::bitwise_and());
    assert_eq!(c, 0b0000_1100_0011_0000);

    let mut d = b;
    collective::reduce_local_into(&a, &mut d, SystemOperation::bitwise_or());
    assert_eq!(d, 0b0011_1111_1111_1100);

    let mut e = b;
    collective::reduce_local_into(&a, &mut e, SystemOperation::bitwise_xor());
    assert_eq!(e, 0b0011_0011_1100_1100);

    let f = (0..size).collect::<Vec<_>>();
    let mut g: Rank = 0;

    world.reduce_scatter_block_into(&f[..], &mut g, SystemOperation::product());
    assert_eq!(g, rank.wrapping_pow(size as u32));

    test_user_operations(universe.world());

    let mut i = 0;
    let op = unsafe { UnsafeUserOperation::commutative(unsafe_add) };
    world.all_reduce_into(&(rank + 1), &mut i, &op);
    assert_eq!(i, size * (size + 1) / 2);
}

fn reduce_into_root<S, R, O>(&self, sendbuf: &S, recvbuf: &mut R, op: O)

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

Performs a global reduction under the operation op of the input data in sendbuf and stores the result on the Root process.

This function must be called on the root process.

Examples

See examples/reduce.rs

Standard section(s)

5.9.1

Examples found in repository

examples/reduce.rs (line 80)

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

    if rank == root_rank {
        let mut sum: Rank = 0;
        world
            .process_at_rank(root_rank)
            .reduce_into_root(&rank, &mut sum, SystemOperation::sum());
        assert_eq!(sum, size * (size - 1) / 2);
    } else {
        world
            .process_at_rank(root_rank)
            .reduce_into(&rank, SystemOperation::sum());
    }

    let mut max: Rank = -1;

    world.all_reduce_into(&rank, &mut max, SystemOperation::max());
    assert_eq!(max, size - 1);

    let a: u16 = 0b0000_1111_1111_0000;
    let b: u16 = 0b0011_1100_0011_1100;

    let mut c = b;
    collective::reduce_local_into(&a, &mut c, SystemOperation::bitwise_and());
    assert_eq!(c, 0b0000_1100_0011_0000);

    let mut d = b;
    collective::reduce_local_into(&a, &mut d, SystemOperation::bitwise_or());
    assert_eq!(d, 0b0011_1111_1111_1100);

    let mut e = b;
    collective::reduce_local_into(&a, &mut e, SystemOperation::bitwise_xor());
    assert_eq!(e, 0b0011_0011_1100_1100);

    let f = (0..size).collect::<Vec<_>>();
    let mut g: Rank = 0;

    world.reduce_scatter_block_into(&f[..], &mut g, SystemOperation::product());
    assert_eq!(g, rank.wrapping_pow(size as u32));

    test_user_operations(universe.world());

    let mut i = 0;
    let op = unsafe { UnsafeUserOperation::commutative(unsafe_add) };
    world.all_reduce_into(&(rank + 1), &mut i, &op);
    assert_eq!(i, size * (size + 1) / 2);
}

fn immediate_broadcast_into<'a, Sc, Buf>( &self, scope: Sc, buf: &'a mut Buf, ) -> Request<'a, Sc>

where Buf: 'a + BufferMut + ?Sized, Sc: Scope<'a>,

Initiate broadcast of a value from the Root process to all other processes.

Examples

See examples/immediate_broadcast.rs

Standard section(s)

5.12.2

Examples found in repository

examples/immediate_broadcast.rs (line 20)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let root_rank = 0;
    let root_process = world.process_at_rank(root_rank);

    let mut x;
    if world.rank() == root_rank {
        x = 2_u64.pow(10);
        println!("Root broadcasting value: {}.", x);
    } else {
        x = 0_u64;
    }
    mpi::request::scope(|scope| {
        root_process.immediate_broadcast_into(scope, &mut x).wait();
    });
    println!("Rank {} received value: {}.", world.rank(), x);
    assert_eq!(x, 1024);
    println!();

    let mut a;
    let n = 4;
    if world.rank() == root_rank {
        a = (1..).map(|i| 2_u64.pow(i)).take(n).collect::<Vec<_>>();
        println!("Root broadcasting value: {:?}.", &a[..]);
    } else {
        a = std::iter::repeat(0_u64).take(n).collect::<Vec<_>>();
    }
    mpi::request::scope(|scope| {
        root_process
            .immediate_broadcast_into(scope, &mut a[..])
            .wait();
    });
    println!("Rank {} received value: {:?}.", world.rank(), &a[..]);
    assert_eq!(&a[..], &[2, 4, 8, 16]);
}

fn immediate_gather_into<'a, Sc, S>( &self, scope: Sc, sendbuf: &'a S, ) -> Request<'a, Sc>

where S: 'a + Buffer + ?Sized, Sc: Scope<'a>,

Initiate non-blocking gather of the contents of all sendbufs on Root &self.

This function must be called on all non-root processes.

Examples

See examples/immediate_gather.rs

Standard section(s)

5.12.3

Examples found in repository

examples/immediate_gather.rs (line 31)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let root_rank = 0;
    let root_process = world.process_at_rank(root_rank);

    let count = world.size() as usize;
    let i = 2_u64.pow(world.rank() as u32 + 1);

    if world.rank() == root_rank {
        let mut a = vec![0u64; count];
        mpi::request::scope(|scope| {
            root_process
                .immediate_gather_into_root(scope, &i, &mut a[..])
                .wait();
        });
        println!("Root gathered sequence: {:?}.", a);
        assert!(a
            .iter()
            .enumerate()
            .all(|(a, &b)| b == 2u64.pow(a as u32 + 1)));
    } else {
        mpi::request::scope(|scope| {
            root_process.immediate_gather_into(scope, &i).wait();
        });
    }

    let factor = world.rank() as u64 + 1;
    let a = (1_u64..)
        .take(count)
        .map(|x| x * factor)
        .collect::<Vec<_>>();

    if world.rank() == root_rank {
        let mut t = vec![0u64; count * count];
        mpi::request::scope(|scope| {
            root_process
                .immediate_gather_into_root(scope, &a[..], &mut t[..])
                .wait();
        });
        println!("Root gathered table:");
        for r in t.chunks(count) {
            println!("{:?}", r);
        }
        assert!((0_u64..)
            .zip(t.iter())
            .all(|(a, &b)| b == (a / count as u64 + 1) * (a % count as u64 + 1)));
    } else {
        mpi::request::scope(|scope| {
            root_process.immediate_gather_into(scope, &a[..]).wait();
        });
    }

    let d = UserDatatype::contiguous(count as Count, &u64::equivalent_datatype());
    let sv = unsafe { View::with_count_and_datatype(&a[..], 1, &d) };

    if world.rank() == root_rank {
        let mut t = vec![0u64; count * count];

        {
            let mut rv =
                unsafe { MutView::with_count_and_datatype(&mut t[..], count as Count, &d) };
            mpi::request::scope(|scope| {
                root_process
                    .immediate_gather_into_root(scope, &sv, &mut rv)
                    .wait();
            });
        }

        println!("Root gathered table:");
        for r in t.chunks(count) {
            println!("{:?}", r);
        }
        assert!((0_u64..)
            .zip(t.iter())
            .all(|(a, &b)| b == (a / count as u64 + 1) * (a % count as u64 + 1)));
    } else {
        mpi::request::scope(|scope| {
            root_process.immediate_gather_into(scope, &sv).wait();
        });
    }
}

fn immediate_gather_into_root<'a, Sc, S, R>( &self, scope: Sc, sendbuf: &'a S, recvbuf: &'a mut R, ) -> Request<'a, Sc>

where S: 'a + Buffer + ?Sized, R: 'a + BufferMut + ?Sized, Sc: Scope<'a>,

Initiate non-blocking gather of the contents of all sendbufs on Root &self.

This function must be called on the root processes.

Examples

See examples/immediate_gather.rs

Standard section(s)

5.12.3

Examples found in repository

examples/immediate_gather.rs (line 21)

fn main() {
    let universe = mpi::initialize().unwrap();
    let world = universe.world();
    let root_rank = 0;
    let root_process = world.process_at_rank(root_rank);

    let count = world.size() as usize;
    let i = 2_u64.pow(world.rank() as u32 + 1);

    if world.rank() == root_rank {
        let mut a = vec![0u64; count];
        mpi::request::scope(|scope| {
            root_process
                .immediate_gather_into_root(scope, &i, &mut a[..])
                .wait();
        });
        println!("Root gathered sequence: {:?}.", a);
        assert!(a
            .iter()
            .enumerate()
            .all(|(a, &b)| b == 2u64.pow(a as u32 + 1)));
    } else {
        mpi::request::scope(|scope| {
            root_process.immediate_gather_into(scope, &i).wait();
        });
    }

    let factor = world.rank() as u64 + 1;
    let a = (1_u64..)
        .take(count)
        .map(|x| x * factor)
        .collect::<Vec<_>>();

    if world.rank() == root_rank {
        let mut t = vec![0u64; count * count];
        mpi::request::scope(|scope| {
            root_process
                .immediate_gather_into_root(scope, &a[..], &mut t[..])
                .wait();
        });
        println!("Root gathered table:");
        for r in t.chunks(count) {
            println!("{:?}", r);
        }
        assert!((0_u64..)
            .zip(t.iter())
            .all(|(a, &b)| b == (a / count as u64 + 1) * (a % count as u64 + 1)));
    } else {
        mpi::request::scope(|scope| {
            root_process.immediate_gather_into(scope, &a[..]).wait();
        });
    }

    let d = UserDatatype::contiguous(count as Count, &u64::equivalent_datatype());
    let sv = unsafe { View::with_count_and_datatype(&a[..], 1, &d) };

    if world.rank() == root_rank {
        let mut t = vec![0u64; count * count];

        {
            let mut rv =
                unsafe { MutView::with_count_and_datatype(&mut t[..], count as Count, &d) };
            mpi::request::scope(|scope| {
                root_process
                    .immediate_gather_into_root(scope, &sv, &mut rv)
                    .wait();
            });
        }

        println!("Root gathered table:");
        for r in t.chunks(count) {
            println!("{:?}", r);
        }
        assert!((0_u64..)
            .zip(t.iter())
            .all(|(a, &b)| b == (a / count as u64 + 1) * (a % count as u64 + 1)));
    } else {
        mpi::request::scope(|scope| {
            root_process.immediate_gather_into(scope, &sv).wait();
        });
    }
}

fn immediate_gather_varcount_into<'a, Sc, S>( &self, scope: Sc, sendbuf: &'a S, ) -> Request<'a, Sc>

where S: 'a + Buffer + ?Sized, Sc: Scope<'a>,

Initiate non-blocking gather of the contents of all sendbufs on Root &self.

This function must be called on all non-root processes.

Examples

See examples/immediate_gather_varcount.rs

Standard section(s)

5.12.3

Examples found in repository

examples/immediate_gather_varcount.rs (line 49)

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

    let rank = world.rank();
    let size = world.size();

    let root_rank = 0;
    let root_process = world.process_at_rank(root_rank);

    let msg: Vec<_> = (0..rank).collect();

    if rank == root_rank {
        let counts: Vec<Count> = (0..size).collect();
        let displs: Vec<Count> = counts
            .iter()
            .scan(0, |acc, &x| {
                let tmp = *acc;
                *acc += x;
                Some(tmp)
            })
            .collect();

        let mut buf = vec![0; (size * (size - 1) / 2) as usize];
        {
            let mut partition = PartitionMut::new(&mut buf[..], counts, &displs[..]);
            mpi::request::scope(|scope| {
                root_process
                    .immediate_gather_varcount_into_root(scope, &msg[..], &mut partition)
                    .wait();
            })
        }

        assert!(buf
            .iter()
            .zip((0..size).flat_map(|r| (0..r)))
            .all(|(&i, j)| i == j));
        println!("{:?}", buf);
    } else {
        mpi::request::scope(|scope| {
            root_process
                .immediate_gather_varcount_into(scope, &msg[..])
                .wait();
        });
    }
}

fn immediate_gather_varcount_into_root<'a, Sc, S, R>( &self, scope: Sc, sendbuf: &'a S, recvbuf: &'a mut R, ) -> Request<'a, Sc>

where S: 'a + Buffer + ?Sized, R: 'a + PartitionedBufferMut + ?Sized, Sc: Scope<'a>,

Initiate non-blocking gather of the contents of all sendbufs on Root &self.

This function must be called on the root processes.

Examples

See examples/immediate_gather_varcount.rs

Standard section(s)

5.12.3

Examples found in repository

examples/immediate_gather_varcount.rs (line 36)

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

    let rank = world.rank();
    let size = world.size();

    let root_rank = 0;
    let root_process = world.process_at_rank(root_rank);

    let msg: Vec<_> = (0..rank).collect();

    if rank == root_rank {
        let counts: Vec<Count> = (0..size).collect();
        let displs: Vec<Count> = counts
            .iter()
            .scan(0, |acc, &x| {
                let tmp = *acc;
                *acc += x;
                Some(tmp)
            })
            .collect();

        let mut buf = vec![0; (size * (size - 1) / 2) as usize];
        {
            let mut partition = PartitionMut::new(&mut buf[..], counts, &displs[..]);
            mpi::request::scope(|scope| {
                root_process
                    .immediate_gather_varcount_into_root(scope, &msg[..], &mut partition)
                    .wait();
            })
        }

        assert!(buf
            .iter()
            .zip((0..size).flat_map(|r| (0..r)))
            .all(|(&i, j)| i == j));
        println!("{:?}", buf);
    } else {
        mpi::request::scope(|scope| {
            root_process
                .immediate_gather_varcount_into(scope, &msg[..])
                .wait();
        });
    }
}

fn immediate_scatter_into<'a, Sc, R>( &self, scope: Sc, recvbuf: &'a mut R, ) -> Request<'a, Sc>

where R: 'a + BufferMut + ?Sized, Sc: Scope<'a>,

Initiate non-blocking scatter of the contents of sendbuf from Root &self.

This function must be called on all non-root processes.

Examples

See examples/immediate_scatter.rs

Standard section(s)

5.12.4

Examples found in repository

examples/immediate_scatter.rs (line 24)

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

    let mut x = 0 as Rank;
    if rank == root_rank {
        let v = (0..size).collect::<Vec<_>>();
        mpi::request::scope(|scope| {
            let req = root_process.immediate_scatter_into_root(scope, &v[..], &mut x);
            req.wait();
        });
    } else {
        mpi::request::scope(|scope| {
            let req = root_process.immediate_scatter_into(scope, &mut x);
            req.wait();
        });
    }
    assert_eq!(x, rank);
}

fn immediate_scatter_into_root<'a, Sc, S, R>( &self, scope: Sc, sendbuf: &'a S, recvbuf: &'a mut R, ) -> Request<'a, Sc>

where S: 'a + Buffer + ?Sized, R: 'a + BufferMut + ?Sized, Sc: Scope<'a>,

Initiate non-blocking scatter of the contents of sendbuf from Root &self.

This function must be called on the root processes.

Examples

See examples/immediate_scatter.rs

Standard section(s)

5.12.4

Examples found in repository

examples/immediate_scatter.rs (line 19)

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

    let mut x = 0 as Rank;
    if rank == root_rank {
        let v = (0..size).collect::<Vec<_>>();
        mpi::request::scope(|scope| {
            let req = root_process.immediate_scatter_into_root(scope, &v[..], &mut x);
            req.wait();
        });
    } else {
        mpi::request::scope(|scope| {
            let req = root_process.immediate_scatter_into(scope, &mut x);
            req.wait();
        });
    }
    assert_eq!(x, rank);
}

fn immediate_scatter_varcount_into<'a, Sc, R>( &self, scope: Sc, recvbuf: &'a mut R, ) -> Request<'a, Sc>

where R: 'a + BufferMut + ?Sized, Sc: Scope<'a>,

Initiate non-blocking scatter of the contents of sendbuf from Root &self.

This function must be called on all non-root processes.

Examples

See examples/immediate_scatter_varcount.rs

Standard section(s)

5.12.4

Examples found in repository

examples/immediate_scatter_varcount.rs (line 40)

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

    let rank = world.rank();
    let size = world.size();

    let root_rank = 0;
    let root_process = world.process_at_rank(root_rank);

    let mut buf = vec![0; rank as usize];

    if rank == root_rank {
        let msg: Vec<_> = (0..size).flat_map(|i| (0..i)).collect();
        let counts: Vec<Count> = (0..size).collect();
        let displs: Vec<Count> = counts
            .iter()
            .scan(0, |acc, &x| {
                let tmp = *acc;
                *acc += x;
                Some(tmp)
            })
            .collect();
        let partition = Partition::new(&msg[..], counts, &displs[..]);
        mpi::request::scope(|scope| {
            root_process
                .immediate_scatter_varcount_into_root(scope, &partition, &mut buf[..])
                .wait();
        });
    } else {
        mpi::request::scope(|scope| {
            root_process
                .immediate_scatter_varcount_into(scope, &mut buf[..])
                .wait();
        });
    }

    assert!(buf.iter().zip(0..rank).all(|(&i, j)| i == j));
    println!("Process {} got message: {:?}", rank, buf);
}

fn immediate_scatter_varcount_into_root<'a, Sc, S, R>( &self, scope: Sc, sendbuf: &'a S, recvbuf: &'a mut R, ) -> Request<'a, Sc>

where S: 'a + PartitionedBuffer + ?Sized, R: 'a + BufferMut + ?Sized, Sc: Scope<'a>,

Initiate non-blocking scatter of the contents of sendbuf from Root &self.

This function must be called on the root processes.

Examples

See examples/immediate_scatter_varcount.rs

Standard section(s)

5.12.4

Examples found in repository

examples/immediate_scatter_varcount.rs (line 34)

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

    let rank = world.rank();
    let size = world.size();

    let root_rank = 0;
    let root_process = world.process_at_rank(root_rank);

    let mut buf = vec![0; rank as usize];

    if rank == root_rank {
        let msg: Vec<_> = (0..size).flat_map(|i| (0..i)).collect();
        let counts: Vec<Count> = (0..size).collect();
        let displs: Vec<Count> = counts
            .iter()
            .scan(0, |acc, &x| {
                let tmp = *acc;
                *acc += x;
                Some(tmp)
            })
            .collect();
        let partition = Partition::new(&msg[..], counts, &displs[..]);
        mpi::request::scope(|scope| {
            root_process
                .immediate_scatter_varcount_into_root(scope, &partition, &mut buf[..])
                .wait();
        });
    } else {
        mpi::request::scope(|scope| {
            root_process
                .immediate_scatter_varcount_into(scope, &mut buf[..])
                .wait();
        });
    }

    assert!(buf.iter().zip(0..rank).all(|(&i, j)| i == j));
    println!("Process {} got message: {:?}", rank, buf);
}

fn immediate_reduce_into<'a, Sc, S, O>( &self, scope: Sc, sendbuf: &'a S, op: O, ) -> Request<'a, Sc>

where S: 'a + Buffer + ?Sized, O: 'a + Operation, Sc: Scope<'a>,

Initiates a non-blacking global reduction under the operation op of the input data in sendbuf and stores the result on the Root process.

This function must be called on all non-root processes.

Examples

See examples/immediate_reduce.rs

Standard section(s)

5.12.7

Examples found in repository

examples/immediate_reduce.rs (line 88)

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

    if rank == root_rank {
        let mut sum: Rank = 0;
        mpi::request::scope(|scope| {
            world
                .process_at_rank(root_rank)
                .immediate_reduce_into_root(scope, &rank, &mut sum, SystemOperation::sum())
                .wait();
        });
        assert_eq!(sum, size * (size - 1) / 2);
    } else {
        mpi::request::scope(|scope| {
            world
                .process_at_rank(root_rank)
                .immediate_reduce_into(scope, &rank, SystemOperation::sum())
                .wait();
        });
    }

    let mut max: Rank = -1;

    mpi::request::scope(|scope| {
        world
            .immediate_all_reduce_into(scope, &rank, &mut max, SystemOperation::max())
            .wait();
    });
    assert_eq!(max, size - 1);

    let a = (0..size).collect::<Vec<_>>();
    let mut b: Rank = 0;

    mpi::request::scope(|scope| {
        world
            .immediate_reduce_scatter_block_into(scope, &a[..], &mut b, SystemOperation::product())
            .wait();
    });
    assert_eq!(b, rank.wrapping_pow(size as u32));

    test_user_operations(universe.world());

    let mut d = 0;
    let op = unsafe { UnsafeUserOperation::commutative(unsafe_add) };
    mpi::request::scope(|scope| {
        world
            .immediate_all_reduce_into(scope, &rank, &mut d, &op)
            .wait();
    });
    assert_eq!(d, size * (size - 1) / 2);
}

fn immediate_reduce_into_root<'a, Sc, S, R, O>( &self, scope: Sc, sendbuf: &'a S, recvbuf: &'a mut R, op: O, ) -> Request<'a, Sc>

where S: 'a + Buffer + ?Sized, R: 'a + BufferMut + ?Sized, O: 'a + Operation, Sc: Scope<'a>,

Initiates a non-blocking global reduction under the operation op of the input data in sendbuf and stores the result on the Root process.

Examples

See examples/immediate_reduce.rs

This function must be called on the root process.

Standard section(s)

5.12.7

Examples found in repository

examples/immediate_reduce.rs (line 80)

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

    if rank == root_rank {
        let mut sum: Rank = 0;
        mpi::request::scope(|scope| {
            world
                .process_at_rank(root_rank)
                .immediate_reduce_into_root(scope, &rank, &mut sum, SystemOperation::sum())
                .wait();
        });
        assert_eq!(sum, size * (size - 1) / 2);
    } else {
        mpi::request::scope(|scope| {
            world
                .process_at_rank(root_rank)
                .immediate_reduce_into(scope, &rank, SystemOperation::sum())
                .wait();
        });
    }

    let mut max: Rank = -1;

    mpi::request::scope(|scope| {
        world
            .immediate_all_reduce_into(scope, &rank, &mut max, SystemOperation::max())
            .wait();
    });
    assert_eq!(max, size - 1);

    let a = (0..size).collect::<Vec<_>>();
    let mut b: Rank = 0;

    mpi::request::scope(|scope| {
        world
            .immediate_reduce_scatter_block_into(scope, &a[..], &mut b, SystemOperation::product())
            .wait();
    });
    assert_eq!(b, rank.wrapping_pow(size as u32));

    test_user_operations(universe.world());

    let mut d = 0;
    let op = unsafe { UnsafeUserOperation::commutative(unsafe_add) };
    mpi::request::scope(|scope| {
        world
            .immediate_all_reduce_into(scope, &rank, &mut d, &op)
            .wait();
    });
    assert_eq!(d, size * (size - 1) / 2);
}

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

impl<'a, C: 'a + Communicator> Root for Process<'a, C>