Struct DynBufferMut

Source

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

Expand description

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§

Source §

impl<'a> DynBufferMut<'a>

Source

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.

Source

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

Tests whether the buffer type matches T.

Source

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)

15fn test_user_operations<C: Communicator>(comm: C) {
16    let rank = comm.rank();
17    let size = comm.size();
18    let mut h = 0;
19    comm.all_reduce_into(
20        &(rank + 1),
21        &mut h,
22        &UserOperation::commutative(|x, y| {
23            let x: &[Rank] = x.downcast().unwrap();
24            let y: &mut [Rank] = y.downcast().unwrap();
25            for (&x_i, y_i) in x.iter().zip(y) {
26                *y_i += x_i;
27            }
28        }),
29    );
30    assert_eq!(h, size * (size + 1) / 2);
31}

More examples

Hide additional examples

examples/immediate_reduce.rs (line 17)

14fn test_user_operations<C: Communicator>(comm: C) {
15    let op = UserOperation::commutative(|x, y| {
16        let x: &[Rank] = x.downcast().unwrap();
17        let y: &mut [Rank] = y.downcast().unwrap();
18        for (&x_i, y_i) in x.iter().zip(y) {
19            *y_i += x_i;
20        }
21    });
22    let rank = comm.rank();
23    let size = comm.size();
24    let mut c = 0;
25    mpi::request::scope(|scope| {
26        comm.immediate_all_reduce_into(scope, &rank, &mut c, &op)
27            .wait();
28    });
29    assert_eq!(c, size * (size - 1) / 2);
30}

Source

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)

6fn main() {
7    let universe = mpi::initialize().unwrap();
8    let world = universe.world();
9
10    let root_process = world.process_at_rank(0);
11
12    let int_type = i32::equivalent_datatype().dup();
13
14    let mut ints = if world.rank() == 0 {
15        [1i32, 2, 3, 4]
16    } else {
17        [0, 0, 0, 0]
18    };
19
20    let mut buffer =
21        unsafe { DynBufferMut::from_raw(ints.as_mut_ptr(), ints.count(), int_type.as_ref()) };
22
23    root_process.broadcast_into(&mut buffer);
24
25    assert_eq!([1, 2, 3, 4], ints);
26}