Struct mpi::datatype::PartitionMut

pub struct PartitionMut<'b, B: 'b + ?Sized, C, D> { /* private fields */ }

Adds a partitioning to an existing BufferMut so that it becomes Partitioned

Implementations

impl<'b, B, C, D> PartitionMut<'b, B, C, D>

where B: 'b + BufferMut + ?Sized, C: Borrow<[Count]>, D: Borrow<[Count]>,

pub fn new(buf: &mut B, counts: C, displs: D) -> PartitionMut<'_, B, C, D>

Partition buf using counts and displs

Examples found in repository

examples/all_gather_varcount.rs (line 28)

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

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

    let msg: Vec<_> = (0..rank).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 mut buf = vec![0; (size * (size - 1) / 2) as usize];
    {
        let mut partition = PartitionMut::new(&mut buf[..], counts, &displs[..]);
        world.all_gather_varcount_into(&msg[..], &mut partition);
    }

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

examples/immediate_all_gather_varcount.rs (line 28)

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

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

    let msg: Vec<_> = (0..rank).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 mut buf = vec![0; (size * (size - 1) / 2) as usize];
    {
        let mut partition = PartitionMut::new(&mut buf[..], counts, &displs[..]);
        mpi::request::scope(|scope| {
            let req = world.immediate_all_gather_varcount_into(scope, &msg[..], &mut partition);
            req.wait();
        });
    }

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

examples/gather_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 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[..]);
    }
}

examples/immediate_gather_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 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();
        });
    }
}

Trait Implementations

impl<'b, B, C, D> AsDatatype for PartitionMut<'b, B, C, D>

where B: 'b + AsDatatype + ?Sized,

type Out = <B as AsDatatype>::Out

The type of the associated MPI datatype (e.g. SystemDatatype or UserDatatype)

fn as_datatype(&self) -> Self::Out

The associated MPI datatype

impl<'b, B, C, D> Partitioned for PartitionMut<'b, B, C, D>

where B: 'b + ?Sized, C: Borrow<[Count]>, D: Borrow<[Count]>,

fn counts(&self) -> &[Count]

The count of elements in each partition.

fn displs(&self) -> &[Count]

The displacement from the start of the buffer for each partition.

impl<'b, B, C, D> PointerMut for PartitionMut<'b, B, C, D>

where B: 'b + PointerMut + ?Sized,

fn pointer_mut(&mut self) -> *mut c_void

A mutable pointer to the starting address in memory

impl<'b, B, C, D> PartitionedBufferMut for PartitionMut<'b, B, C, D>

where B: 'b + PointerMut + AsDatatype + ?Sized, C: Borrow<[Count]>, D: Borrow<[Count]>,