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

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<'b, Buf: ?Sized>(&self,
                                             buf: &'b mut Buf)
                                             -> WriteRequest<'b, Buf> where Buf: 'b + BufferMut

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

fn immediate_gather_into<'s, S: ?Sized>(&self,
                                        sendbuf: &'s S)
                                        -> ReadRequest<'s, S> where S: 's + Buffer

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

fn immediate_gather_into_root<'s, 'r, S: ?Sized, R: ?Sized>(&self,
                                                            sendbuf: &'s S,
                                                            recvbuf: &'r mut R)
                                                            -> ReadWriteRequest<'s, 'r, S, R> where S: 's + Buffer, R: 'r + BufferMut

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

fn immediate_gather_varcount_into<'s, S: ?Sized>(&self,
                                                 sendbuf: &'s S)
                                                 -> ReadRequest<'s, S> where S: 's + Buffer

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

fn immediate_gather_varcount_into_root<'s, 'r, S: ?Sized, R: ?Sized>(&self,
                                                                     sendbuf: &'s S,
                                                                     recvbuf: &'r mut R)
                                                                     -> ReadWriteRequest<'s, 'r, S, R> where S: 's + Buffer, R: 'r + PartitionedBufferMut

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

fn immediate_scatter_into<'r, R: ?Sized>(&self,
                                         recvbuf: &'r mut R)
                                         -> WriteRequest<'r, R> where R: 'r + BufferMut

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

fn immediate_scatter_into_root<'s, 'r, S: ?Sized, R: ?Sized>(&self,
                                                             sendbuf: &'s S,
                                                             recvbuf: &'r mut R)
                                                             -> ReadWriteRequest<'s, 'r, S, R> where S: 's + Buffer, R: 'r + BufferMut

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

fn immediate_scatter_varcount_into<'r, R: ?Sized>(&self,
                                                  recvbuf: &'r mut R)
                                                  -> WriteRequest<'r, R> where R: 'r + BufferMut

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

fn immediate_scatter_varcount_into_root<'s, 'r, S: ?Sized, R: ?Sized>(&self,
                                                                      sendbuf: &'s S,
                                                                      recvbuf: &'r mut R)
                                                                      -> ReadWriteRequest<'s, 'r, S, R> where S: 's + PartitionedBuffer, R: 'r + BufferMut

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

fn immediate_reduce_into<'s, S: ?Sized, O>(&self,
                                           sendbuf: &'s S,
                                           op: &O)
                                           -> ReadRequest<'s, S> where S: 's + Buffer, O: Operation

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<'s, 'r, S: ?Sized, R: ?Sized, O>(&self,
                                                               sendbuf: &'s S,
                                                               recvbuf: &'r mut R,
                                                               op: &O)
                                                               -> ReadWriteRequest<'s, 'r, S, R> where S: 's + Buffer, R: 'r + BufferMut, O: Operation

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<'b, Buf: ?Sized>(&self,
                                                    buf: &'b mut Buf,
                                                    tag: Tag)
                                                    -> WriteRequest<'b, Buf> where Buf: 'b + BufferMut

Initiate an immediate (non-blocking) receive operation.

fn immediate_receive_into<'b, Buf: ?Sized>(&self,
                                           buf: &'b mut Buf)
                                           -> WriteRequest<'b, Buf> where Buf: 'b + BufferMut

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<'b, Buf: ?Sized>(&self,
                                            buf: &'b Buf,
                                            tag: Tag)
                                            -> ReadRequest<'b, Buf> where Buf: 'b + Buffer

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

fn immediate_send<'b, Buf: ?Sized>(&self, buf: &'b Buf) -> ReadRequest<'b, Buf> where Buf: 'b + Buffer

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

fn immediate_buffered_send_with_tag<'b, Buf: ?Sized>(&self,
                                                     buf: &'b Buf,
                                                     tag: Tag)
                                                     -> ReadRequest<'b, Buf> where Buf: 'b + Buffer

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

fn immediate_buffered_send<'b, Buf: ?Sized>(&self,
                                            buf: &'b Buf)
                                            -> ReadRequest<'b, Buf> where Buf: 'b + Buffer

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

fn immediate_synchronous_send_with_tag<'b, Buf: ?Sized>(&self,
                                                        buf: &'b Buf,
                                                        tag: Tag)
                                                        -> ReadRequest<'b, Buf> where Buf: 'b + Buffer

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

fn immediate_synchronous_send<'b, Buf: ?Sized>(&self,
                                               buf: &'b Buf)
                                               -> ReadRequest<'b, Buf> where Buf: 'b + Buffer

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

fn immediate_ready_send_with_tag<'b, Buf: ?Sized>(&self,
                                                  buf: &'b Buf,
                                                  tag: Tag)
                                                  -> ReadRequest<'b, Buf> where Buf: 'b + Buffer

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

fn immediate_ready_send<'b, Buf: ?Sized>(&self,
                                         buf: &'b Buf)
                                         -> ReadRequest<'b, Buf> where Buf: 'b + Buffer

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.