Struct mpi::datatype::DynBufferMut

pub struct DynBufferMut<'a> { /* private fields */ }

A mutable dynamically-typed buffer.

The buffer has a definite length and MPI datatype, but it is not yet known which Rust type it corresponds to. This is the MPI analogue of &mut Any. It is semantically equivalent to the mutable trait object reference &mut BufferMut.

Implementations

impl<'a> DynBufferMut<'a>

pub fn new<T: Equivalence>(buf: &'a mut [T]) -> Self

Creates a mutable buffer from a mutable slice with whose type has an MPI equivalent.

pub fn is<T: Equivalence>(&self) -> bool

Tests whether the buffer type matches T.

pub fn downcast<T: Equivalence>(self) -> Option<&'a mut [T]>

Returns some mutable slice if the type matches T, or None if it doesn’t.

Examples found in repository

examples/reduce.rs (line 24)

fn test_user_operations<C: Communicator>(comm: C) {
    let rank = comm.rank();
    let size = comm.size();
    let mut h = 0;
    comm.all_reduce_into(
        &(rank + 1),
        &mut h,
        &UserOperation::commutative(|x, y| {
            let x: &[Rank] = x.downcast().unwrap();
            let y: &mut [Rank] = y.downcast().unwrap();
            for (&x_i, y_i) in x.iter().zip(y) {
                *y_i += x_i;
            }
        }),
    );
    assert_eq!(h, size * (size + 1) / 2);
}

examples/immediate_reduce.rs (line 17)

fn test_user_operations<C: Communicator>(comm: C) {
    let op = UserOperation::commutative(|x, y| {
        let x: &[Rank] = x.downcast().unwrap();
        let y: &mut [Rank] = y.downcast().unwrap();
        for (&x_i, y_i) in x.iter().zip(y) {
            *y_i += x_i;
        }
    });
    let rank = comm.rank();
    let size = comm.size();
    let mut c = 0;
    mpi::request::scope(|scope| {
        comm.immediate_all_reduce_into(scope, &rank, &mut c, &op)
            .wait();
    });
    assert_eq!(c, size * (size - 1) / 2);
}

pub unsafe fn from_raw<T>( ptr: *mut T, len: Count, datatype: DatatypeRef<'a> ) -> Self

Creates a buffer from its raw components. The buffer must remain valid for 'a and the pointer must not be null.

Safety

• Buffer pointed to by ptr must live as long as 'a. There must be no other live reference to the buffer in Rust.
• ptr must point to an object that holds len elements of the type described by datatype.

Examples found in repository

examples/datatype_dup.rs (line 21)

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);
}

pub fn len(&self) -> usize

Returns the number of elements in the buffer.

pub fn is_empty(&self) -> bool

Returns true if the buffer is empty

pub fn as_ptr(&self) -> *const c_void

Returns the underlying raw pointer.

pub fn as_mut_ptr(&mut self) -> *mut c_void

Returns the underlying raw pointer.

pub fn reborrow(&self) -> DynBuffer<'_>

Reborrows the buffer with a shorter lifetime.

pub fn reborrow_mut(&mut self) -> DynBufferMut<'_>

Reborrows the buffer mutably with a shorter lifetime.

pub fn downgrade(self) -> DynBuffer<'a>

Makes the buffer immutable.

Trait Implementations

impl<'a> AsDatatype for DynBufferMut<'a>

type Out = DatatypeRef<'a>

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

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

The associated MPI datatype

impl<'a> Collection for DynBufferMut<'a>

fn count(&self) -> Count

How many things are in this collection.

impl<'a> Debug for DynBufferMut<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> Pointer for DynBufferMut<'a>

fn pointer(&self) -> *const c_void

A pointer to the starting address in memory

impl<'a> PointerMut for DynBufferMut<'a>

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

A mutable pointer to the starting address in memory

impl<'a> Buffer for DynBufferMut<'a>

impl<'a> BufferMut for DynBufferMut<'a>

impl<'a> Send for DynBufferMut<'a>

impl<'a> Sync for DynBufferMut<'a>