Struct mpi::datatype::DynBuffer

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

An immutable 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 &Any. It is semantically equivalent to the trait object reference &Buffer.

Implementations

impl<'a> DynBuffer<'a>

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

Creates a buffer from a 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 [T]>

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

Examples found in repository

examples/reduce.rs (line 23)

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 16)

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: *const 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
• ptr must point to an object that holds len elements of the type described by datatype.

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.

Trait Implementations

impl<'a> AsDatatype for DynBuffer<'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> Clone for DynBuffer<'a>

fn clone(&self) -> DynBuffer<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Collection for DynBuffer<'a>

fn count(&self) -> Count

How many things are in this collection.

impl<'a> Debug for DynBuffer<'a>

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

Formats the value using the given formatter.

impl<'a> Pointer for DynBuffer<'a>

fn pointer(&self) -> *const c_void

A pointer to the starting address in memory

impl<'a> Buffer for DynBuffer<'a>

impl<'a> Copy for DynBuffer<'a>

impl<'a> Send for DynBuffer<'a>

impl<'a> Sync for DynBuffer<'a>