![]() |
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) |
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.
Definition at line 156 of file par_cntrl_comm.h.
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.
bool par::cntrl::probe | ( | void | ) | [inline] |
Definition at line 38 of file par_cntrl_comm.h.
int par::cntrl::receive | ( | par::cntrl::proc_t | whom, | |
mtype * | mess | |||
) | [inline] |
Definition at line 211 of file par_cntrl_comm.h.
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.
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.
int par::cntrl::receive< void > | ( | par::cntrl::proc_t | whom, | |
void * | mess, | |||
off_t | n, | |||
int | msgtag | |||
) | [inline] |
int par::cntrl::send | ( | par::cntrl::proc_t const | whom, | |
mtype const * | mess | |||
) | [inline] |
Definition at line 80 of file par_cntrl_comm.h.
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.
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.
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.
sync
routines in other parXXL levels this returns PTHREAD_BARRIER_SERIAL_THREAD for exactly one parXXL process of the pack.par::mem::sync
Definition at line 984 of file par_cntrl_comm.h.