Struct mpi::topology::Process

pub struct Process<'a, C> where
    C: 'a + Communicator,  { /* fields omitted */ }

Identifies a process by its Rank within a certain communicator.

Methods

impl<'a, C> Process<'a, C> where
    C: 'a + Communicator, 

pub fn rank(&self) -> Rank

The process rank

Trait Implementations

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

fn root_rank(&self) -> Rank

Rank of the root process

fn broadcast_into<Buf: ?Sized>(&self, buffer: &mut Buf) where
    Buf: BufferMut, 

Broadcast of the contents of a buffer

fn gather_into<S: ?Sized>(&self, sendbuf: &S) where
    S: Buffer, 

Gather contents of buffers on Root.

fn gather_into_root<S: ?Sized, R: ?Sized>(&self, sendbuf: &S, recvbuf: &mut R) where
    S: Buffer,
    R: BufferMut, 

Gather contents of buffers on Root.

fn gather_varcount_into<S: ?Sized>(&self, sendbuf: &S) where
    S: Buffer, 

Gather contents of buffers on Root.

fn gather_varcount_into_root<S: ?Sized, R: ?Sized>(
    &self,
    sendbuf: &S,
    recvbuf: &mut R
) where
    S: Buffer,
    R: PartitionedBufferMut, 

Gather contents of buffers on Root.

fn scatter_into<R: ?Sized>(&self, recvbuf: &mut R) where
    R: BufferMut, 

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

fn scatter_into_root<S: ?Sized, R: ?Sized>(&self, sendbuf: &S, recvbuf: &mut R) where
    S: Buffer,
    R: BufferMut, 

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

fn scatter_varcount_into<R: ?Sized>(&self, recvbuf: &mut R) where
    R: BufferMut, 

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

fn scatter_varcount_into_root<S: ?Sized, R: ?Sized>(
    &self,
    sendbuf: &S,
    recvbuf: &mut R
) where
    S: PartitionedBuffer,
    R: BufferMut, 

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

fn reduce_into<S: ?Sized, O>(&self, sendbuf: &S, op: O) where
    S: Buffer,
    O: Operation, 

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

fn reduce_into_root<S: ?Sized, R: ?Sized, O>(
    &self,
    sendbuf: &S,
    recvbuf: &mut R,
    op: O
) where
    S: Buffer,
    R: BufferMut,
    O: Operation, 

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

fn immediate_broadcast_into<'a, Sc, Buf: ?Sized>(
    &self,
    scope: Sc,
    buf: &'a mut Buf
) -> Request<'a, Sc> where
    Buf: 'a + BufferMut,
    Sc: Scope<'a>, 

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

fn immediate_gather_into<'a, Sc, S: ?Sized>(
    &self,
    scope: Sc,
    sendbuf: &'a S
) -> Request<'a, Sc> where
    S: 'a + Buffer,
    Sc: Scope<'a>, 

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

fn immediate_gather_into_root<'a, Sc, S: ?Sized, R: ?Sized>(
    &self,
    scope: Sc,
    sendbuf: &'a S,
    recvbuf: &'a mut R
) -> Request<'a, Sc> where
    S: 'a + Buffer,
    R: 'a + BufferMut,
    Sc: Scope<'a>, 

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

fn immediate_gather_varcount_into<'a, Sc, S: ?Sized>(
    &self,
    scope: Sc,
    sendbuf: &'a S
) -> Request<'a, Sc> where
    S: 'a + Buffer,
    Sc: Scope<'a>, 

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

fn immediate_gather_varcount_into_root<'a, Sc, S: ?Sized, R: ?Sized>(
    &self,
    scope: Sc,
    sendbuf: &'a S,
    recvbuf: &'a mut R
) -> Request<'a, Sc> where
    S: 'a + Buffer,
    R: 'a + PartitionedBufferMut,
    Sc: Scope<'a>, 

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

fn immediate_scatter_into<'a, Sc, R: ?Sized>(
    &self,
    scope: Sc,
    recvbuf: &'a mut R
) -> Request<'a, Sc> where
    R: 'a + BufferMut,
    Sc: Scope<'a>, 

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

fn immediate_scatter_into_root<'a, Sc, S: ?Sized, R: ?Sized>(
    &self,
    scope: Sc,
    sendbuf: &'a S,
    recvbuf: &'a mut R
) -> Request<'a, Sc> where
    S: 'a + Buffer,
    R: 'a + BufferMut,
    Sc: Scope<'a>, 

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

fn immediate_scatter_varcount_into<'a, Sc, R: ?Sized>(
    &self,
    scope: Sc,
    recvbuf: &'a mut R
) -> Request<'a, Sc> where
    R: 'a + BufferMut,
    Sc: Scope<'a>, 

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

fn immediate_scatter_varcount_into_root<'a, Sc, S: ?Sized, R: ?Sized>(
    &self,
    scope: Sc,
    sendbuf: &'a S,
    recvbuf: &'a mut R
) -> Request<'a, Sc> where
    S: 'a + PartitionedBuffer,
    R: 'a + BufferMut,
    Sc: Scope<'a>, 

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

fn immediate_reduce_into<'a, Sc, S: ?Sized, O>(
    &self,
    scope: Sc,
    sendbuf: &'a S,
    op: O
) -> Request<'a, Sc> where
    S: 'a + Buffer,
    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.

fn immediate_reduce_into_root<'a, Sc, S: ?Sized, R: ?Sized, O>(
    &self,
    scope: Sc,
    sendbuf: &'a S,
    recvbuf: &'a mut R,
    op: O
) -> Request<'a, Sc> where
    S: 'a + Buffer,
    R: 'a + BufferMut,
    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.

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

fn source_rank(&self) -> Rank

Rank that identifies the source

fn probe_with_tag(&self, tag: Tag) -> Status

Probe a source for incoming messages.

fn probe(&self) -> Status

Probe a source for incoming messages.

fn matched_probe_with_tag(&self, tag: Tag) -> (Message, Status)

Probe a source for incoming messages with guaranteed reception.

fn matched_probe(&self) -> (Message, Status)

Probe a source for incoming messages with guaranteed reception.

fn receive_with_tag<Msg>(&self, tag: Tag) -> (Msg, Status) where
    Msg: Equivalence, 

Receive a message containing a single instance of type Msg.

fn receive<Msg>(&self) -> (Msg, Status) where
    Msg: Equivalence, 

Receive a message containing a single instance of type Msg.

fn receive_into_with_tag<Buf: ?Sized>(&self, buf: &mut Buf, tag: Tag) -> Status where
    Buf: BufferMut, 

Receive a message into a Buffer.

fn receive_into<Buf: ?Sized>(&self, buf: &mut Buf) -> Status where
    Buf: BufferMut, 

Receive a message into a Buffer.

fn receive_vec_with_tag<Msg>(&self, tag: Tag) -> (Vec<Msg>, Status) where
    Msg: Equivalence, 

Receive a message containing multiple instances of type Msg into a Vec.

fn receive_vec<Msg>(&self) -> (Vec<Msg>, Status) where
    Msg: Equivalence, 

Receive a message containing multiple instances of type Msg into a Vec.

fn immediate_receive_into_with_tag<'a, Sc, Buf: ?Sized>(
    &self,
    scope: Sc,
    buf: &'a mut Buf,
    tag: Tag
) -> Request<'a, Sc> where
    Buf: 'a + BufferMut,
    Sc: Scope<'a>, 

Initiate an immediate (non-blocking) receive operation.

fn immediate_receive_into<'a, Sc, Buf: ?Sized>(
    &self,
    scope: Sc,
    buf: &'a mut Buf
) -> Request<'a, Sc> where
    Buf: 'a + BufferMut,
    Sc: Scope<'a>, 

Initiate an immediate (non-blocking) receive operation.

fn immediate_receive_with_tag<Msg>(&self, tag: Tag) -> ReceiveFuture<Msg> where
    Msg: Equivalence, 

Initiate a non-blocking receive operation for messages matching tag tag.

fn immediate_receive<Msg>(&self) -> ReceiveFuture<Msg> where
    Msg: Equivalence, 

Initiate a non-blocking receive operation.

fn immediate_probe_with_tag(&self, tag: Tag) -> Option<Status>

Asynchronously probe a source for incoming messages.

fn immediate_probe(&self) -> Option<Status>

Asynchronously probe a source for incoming messages.

fn immediate_matched_probe_with_tag(
    &self,
    tag: Tag
) -> Option<(Message, Status)>

Asynchronously probe a source for incoming messages with guaranteed reception.

fn immediate_matched_probe(&self) -> Option<(Message, Status)>

Asynchronously probe a source for incoming messages with guaranteed reception.

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

fn destination_rank(&self) -> Rank

Rank that identifies the destination

fn send_with_tag<Buf: ?Sized>(&self, buf: &Buf, tag: Tag) where
    Buf: Buffer, 

Blocking standard mode send operation

fn send<Buf: ?Sized>(&self, buf: &Buf) where
    Buf: Buffer, 

Blocking standard mode send operation

fn buffered_send_with_tag<Buf: ?Sized>(&self, buf: &Buf, tag: Tag) where
    Buf: Buffer, 

Blocking buffered mode send operation

fn buffered_send<Buf: ?Sized>(&self, buf: &Buf) where
    Buf: Buffer, 

Blocking buffered mode send operation

fn synchronous_send_with_tag<Buf: ?Sized>(&self, buf: &Buf, tag: Tag) where
    Buf: Buffer, 

Blocking synchronous mode send operation

fn synchronous_send<Buf: ?Sized>(&self, buf: &Buf) where
    Buf: Buffer, 

Blocking synchronous mode send operation

fn ready_send_with_tag<Buf: ?Sized>(&self, buf: &Buf, tag: Tag) where
    Buf: Buffer, 

Blocking ready mode send operation

fn ready_send<Buf: ?Sized>(&self, buf: &Buf) where
    Buf: Buffer, 

Blocking ready mode send operation

fn immediate_send_with_tag<'a, Sc, Buf: ?Sized>(
    &self,
    scope: Sc,
    buf: &'a Buf,
    tag: Tag
) -> Request<'a, Sc> where
    Buf: 'a + Buffer,
    Sc: Scope<'a>, 

Initiate an immediate (non-blocking) standard mode send operation.

fn immediate_send<'a, Sc, Buf: ?Sized>(
    &self,
    scope: Sc,
    buf: &'a Buf
) -> Request<'a, Sc> where
    Buf: 'a + Buffer,
    Sc: Scope<'a>, 

Initiate an immediate (non-blocking) standard mode send operation.

fn immediate_buffered_send_with_tag<'a, Sc, Buf: ?Sized>(
    &self,
    scope: Sc,
    buf: &'a Buf,
    tag: Tag
) -> Request<'a, Sc> where
    Buf: 'a + Buffer,
    Sc: Scope<'a>, 

Initiate an immediate (non-blocking) buffered mode send operation.

fn immediate_buffered_send<'a, Sc, Buf: ?Sized>(
    &self,
    scope: Sc,
    buf: &'a Buf
) -> Request<'a, Sc> where
    Buf: 'a + Buffer,
    Sc: Scope<'a>, 

Initiate an immediate (non-blocking) buffered mode send operation.

fn immediate_synchronous_send_with_tag<'a, Sc, Buf: ?Sized>(
    &self,
    scope: Sc,
    buf: &'a Buf,
    tag: Tag
) -> Request<'a, Sc> where
    Buf: 'a + Buffer,
    Sc: Scope<'a>, 

Initiate an immediate (non-blocking) synchronous mode send operation.

fn immediate_synchronous_send<'a, Sc, Buf: ?Sized>(
    &self,
    scope: Sc,
    buf: &'a Buf
) -> Request<'a, Sc> where
    Buf: 'a + Buffer,
    Sc: Scope<'a>, 

Initiate an immediate (non-blocking) synchronous mode send operation.

fn immediate_ready_send_with_tag<'a, Sc, Buf: ?Sized>(
    &self,
    scope: Sc,
    buf: &'a Buf,
    tag: Tag
) -> Request<'a, Sc> where
    Buf: 'a + Buffer,
    Sc: Scope<'a>, 

Initiate an immediate (non-blocking) ready mode send operation.

fn immediate_ready_send<'a, Sc, Buf: ?Sized>(
    &self,
    scope: Sc,
    buf: &'a Buf
) -> Request<'a, Sc> where
    Buf: 'a + Buffer,
    Sc: Scope<'a>, 

Initiate an immediate (non-blocking) ready mode send operation.

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

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

fn clone(&self) -> Process<'a, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

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

type Out = C

The type of the associated communicator

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

Returns the associated communicator.