Point to point
[User Interfaces for Communication]

How to communicate with specific parXXL processes. More...

Collaboration diagram for Point to point:

Functions

void par::cntrl::clear_round (void)
void par::cntrl::clear_send (void)
template<class mtype >
int par::cntrl::listen (mtype *mess, off_t n)
template<class mtype >
int par::cntrl::listen (mtype *mess, off_t n, int mstag)
 Receive message mess from somebody.
template<>
int par::cntrl::listen< void > (void *mess, off_t n, int msgtag)
bool par::cntrl::probe (void)
template<class mtype >
int par::cntrl::receive (par::cntrl::proc_t whom, mtype *mess)
template<class mtype >
int par::cntrl::receive (par::cntrl::proc_t whom, mtype *mess, off_t n)
template<class mtype >
int par::cntrl::receive (par::cntrl::proc_t whom, mtype *mess, off_t n, int msgtag)
 Receive message mess from whom.
template<>
int par::cntrl::receive< void > (par::cntrl::proc_t whom, void *mess, off_t n, int msgtag)
template<class mtype >
int par::cntrl::send (par::cntrl::proc_t const whom, mtype const *mess)
template<class mtype >
int par::cntrl::send (par::cntrl::proc_t const whom, mtype const *mess, off_t const n)
template<class mtype >
int par::cntrl::send (par::cntrl::proc_t const whom, mtype const *mess, off_t const n, int msgtag)
 Send message mess to whom.
template<>
int par::cntrl::send< void > (par::cntrl::proc_t const whom, void const *mess, off_t const n, int msgtag)
int par::cntrl::sync (void)

Detailed Description

How to communicate with specific parXXL processes.

Function Documentation

void par::cntrl::clear_round ( void   )  [inline]

Block until all data of this superstep has arrived and promote this parXXL process to the next superstep.

par::cntrl::clear_round must be called after all receive operations in a communication phase have been effected. It terminates the actual communication round by calling par::cntrl::force_next_round(). An implementation may issue the necessary operations to effectively wait to send and receive all pending messages. In a concrete implementation this routine might in fact be empty (not counted the call to par::cntrl::force_next_round()), but don't rely on this.

Definition at line 1000 of file par_cntrl_comm.h.

void par::cntrl::clear_send ( void   )  [inline]

Block until all send data of this superstep can be safely reused.

par::cntrl::clear_send must be called after all send operations in a communication phase have been effected. This is to ensure that an implementation may issue the necessary operations to effectively send out all pending messages. In a concrete implementation this routine might in fact be empty, but don't rely on this.

Definition at line 993 of file par_cntrl_comm.h.

template<class mtype >
int par::cntrl::listen ( mtype *  mess,
off_t  n 
) [inline]

Definition at line 156 of file par_cntrl_comm.h.

template<class mtype >
int par::cntrl::listen ( mtype *  mess,
off_t  n,
int  mstag 
) [inline]

Receive message mess from somebody.

mess is supposed to be n items long.

This doesn't guarantee that the message is actually received at all. You have to issue a par::cntrl::clear_round to ensure this.

Generally you should place par::cntrl::listen early in the superstep.

This is to be used when the process knows that it will receive some message but it doesn't know from which other process. The sender will always have to know whom to send the message.

Definition at line 175 of file par_cntrl_comm.h.

template<>
int par::cntrl::listen< void > ( void *  mess,
off_t  n,
int  msgtag 
) [inline]

bool par::cntrl::probe ( void   )  [inline]

Definition at line 38 of file par_cntrl_comm.h.

template<class mtype >
int par::cntrl::receive ( par::cntrl::proc_t  whom,
mtype *  mess 
) [inline]

Definition at line 211 of file par_cntrl_comm.h.

template<class mtype >
int par::cntrl::receive ( par::cntrl::proc_t  whom,
mtype *  mess,
off_t  n 
) [inline]

Definition at line 203 of file par_cntrl_comm.h.

template<class mtype >
int par::cntrl::receive ( par::cntrl::proc_t  whom,
mtype *  mess,
off_t  n,
int  msgtag 
) [inline]

Receive message mess from whom.

mess is supposed to be n items long.

This doesn't guarantee that the message is actually received at all. You have to issue a par::cntrl::clear_round to ensure this.

Generally you should place par::cntrl::receive early in the superstep.

Definition at line 232 of file par_cntrl_comm.h.

template<>
int par::cntrl::receive< void > ( par::cntrl::proc_t  whom,
void *  mess,
off_t  n,
int  msgtag 
) [inline]

template<class mtype >
int par::cntrl::send ( par::cntrl::proc_t const   whom,
mtype const *  mess 
) [inline]

Definition at line 80 of file par_cntrl_comm.h.

template<class mtype >
int par::cntrl::send ( par::cntrl::proc_t const   whom,
mtype const *  mess,
off_t const   n 
) [inline]

Definition at line 73 of file par_cntrl_comm.h.

template<class mtype >
int par::cntrl::send ( par::cntrl::proc_t const   whom,
mtype const *  mess,
off_t const  n,
int  msgtag 
) [inline]

Send message mess to whom.

mess is supposed to be n items long.

This doesn't guarantee that the message is actually send at all. You have to issue a par::cntrl::clear_send to ensure this.

Generally when you place par::cntrl::send you should already have placed all the par::cntrl::receive for the same superstep.

Definition at line 109 of file par_cntrl_comm.h.

template<>
int par::cntrl::send< void > ( par::cntrl::proc_t const   whom,
void const *  mess,
off_t const   n,
int  msgtag 
) [inline]

int par::cntrl::sync ( void   )  [inline]

Barrier synchronization amoung all parXXL processes.

To allow for a good communication / computation overlap, user code should rarely rely on this.

Returns:
As other sync routines in other parXXL levels this returns PTHREAD_BARRIER_SERIAL_THREAD for exactly one parXXL process of the pack.
See also:
par::sys::sync

par::mem::sync

Definition at line 984 of file par_cntrl_comm.h.


Generated on Tue Oct 13 22:03:48 2009 for parXXL by  doxygen 1.5.8