int MPID_Iprobe(int source, int tag, MPID_Comm *comm, int context_offset,
int *flag, MPI_Status *status)
{
const int context = comm->recvcontext_id + context_offset;
int found = 0;
int mpi_errno = MPI_SUCCESS;
MPIDI_STATE_DECL(MPID_STATE_MPID_IPROBE);
MPIDI_FUNC_ENTER(MPID_STATE_MPID_IPROBE);
if (source == MPI_PROC_NULL)
{
MPIR_Status_set_procnull(status);
/* We set the flag to true because an MPI_Recv with this rank will
return immediately */
*flag = TRUE;
goto fn_exit;
}
/* Check to make sure the communicator hasn't already been revoked */
if (comm->revoked &&
MPIR_AGREE_TAG != MPIR_TAG_MASK_ERROR_BITS(tag & ~MPIR_Process.tagged_coll_mask) &&
MPIR_SHRINK_TAG != MPIR_TAG_MASK_ERROR_BITS(tag & ~MPIR_Process.tagged_coll_mask)) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPIX_ERR_REVOKED,"**revoked");
}
#ifdef ENABLE_COMM_OVERRIDES
if (MPIDI_Anysource_iprobe_fn) {
if (source == MPI_ANY_SOURCE) {
/* if it's anysource, check shm, then check the network.
If still not found, call progress, and check again. */
/* check shm*/
MPIU_THREAD_CS_ENTER(MSGQUEUE,);
found = MPIDI_CH3U_Recvq_FU(source, tag, context, status);
MPIU_THREAD_CS_EXIT(MSGQUEUE,);
if (!found) {
/* not found, check network */
mpi_errno = MPIDI_Anysource_iprobe_fn(tag, comm, context_offset, &found, status);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
if (!found) {
/* still not found, make some progress*/
mpi_errno = MPIDI_CH3_Progress_poke();
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
/* check shm again */
MPIU_THREAD_CS_ENTER(MSGQUEUE,);
found = MPIDI_CH3U_Recvq_FU(source, tag, context, status);
MPIU_THREAD_CS_EXIT(MSGQUEUE,);
if (!found) {
/* check network again */
mpi_errno = MPIDI_Anysource_iprobe_fn(tag, comm, context_offset, &found, status);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
}
}
}
void
MPIDI_RecvMsg_procnull(MPID_Comm * comm,
unsigned is_blocking,
MPI_Status * status,
MPID_Request ** request)
{
if (is_blocking)
{
MPIR_Status_set_procnull(status);
*request = NULL;
}
else
{
MPID_Request * rreq;
rreq = MPIDI_Request_create2();
MPIR_Status_set_procnull(&rreq->status);
rreq->kind = MPID_REQUEST_RECV;
rreq->comm = comm;
MPIR_Comm_add_ref(comm);
MPIDI_Request_complete(rreq);
*request = rreq;
}
}
int
MPID_Probe(int source,
int tag,
MPID_Comm * comm,
int context_offset,
MPI_Status * status)
{
const int context = comm->recvcontext_id + context_offset;
if (source == MPI_PROC_NULL)
{
MPIR_Status_set_procnull(status);
return MPI_SUCCESS;
}
MPID_PROGRESS_WAIT_WHILE(!MPIDI_Recvq_FU_r(source, tag, context, status));
return MPI_SUCCESS;
}
int MPID_Mrecv(void *buf, int count, MPI_Datatype datatype,
MPIR_Request *message, MPI_Status *status)
{
int mpi_errno = MPI_SUCCESS;
MPI_Request req_handle; /* dummy for MPIR_Request_complete */
int active_flag; /* dummy for MPIR_Request_complete */
MPIR_Request *rreq = NULL;
if (message == NULL) {
/* treat as though MPI_MESSAGE_NO_PROC was passed */
MPIR_Status_set_procnull(status);
goto fn_exit;
}
/* There is no optimized MPID_Mrecv at this time because there is no real
* optimization potential in that case. MPID_Recv exists to prevent
* creating a request unnecessarily for messages that are already present
* and eligible for immediate completion. */
mpi_errno = MPID_Imrecv(buf, count, datatype, message, &rreq);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
if (!MPIR_Request_is_complete(rreq)) {
MPID_Progress_state progress_state;
MPID_Progress_start(&progress_state);
while (!MPIR_Request_is_complete(rreq))
{
mpi_errno = MPID_Progress_wait(&progress_state);
if (mpi_errno) {
/* --BEGIN ERROR HANDLING-- */
MPID_Progress_end(&progress_state);
MPIR_ERR_POP(mpi_errno);
/* --END ERROR HANDLING-- */
}
}
MPID_Progress_end(&progress_state);
}
mpi_errno = MPIR_Request_complete(&req_handle, rreq, status, &active_flag);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
int MPID_Recv(void * buf, int count, MPI_Datatype datatype, int rank, int tag,
MPID_Comm * comm, int context_offset,
MPI_Status * status, MPID_Request ** request)
{
/* FIXME: in the common case, we want to simply complete the message
and make as few updates as possible.
Note in addition that this routine is used only by MPI_Recv (a
blocking routine; the intent of the interface (which returns
a request) was to simplify the handling of the case where the
message was not found in the unexpected queue. */
int mpi_errno = MPI_SUCCESS;
MPID_Request * rreq;
int found;
MPIDI_STATE_DECL(MPID_STATE_MPID_RECV);
MPIDI_FUNC_ENTER(MPID_STATE_MPID_RECV);
MPIU_DBG_MSG_FMT(CH3_OTHER,VERBOSE,(MPIU_DBG_FDEST,
"rank=%d, tag=%d, context=%d", rank, tag,
comm->recvcontext_id + context_offset));
if (rank == MPI_PROC_NULL)
{
MPIR_Status_set_procnull(status);
rreq = NULL;
goto fn_exit;
}
/* Check to make sure the communicator hasn't already been revoked */
if (comm->revoked &&
MPIR_AGREE_TAG != MPIR_TAG_MASK_ERROR_BIT(tag & ~MPIR_Process.tagged_coll_mask) &&
MPIR_SHRINK_TAG != MPIR_TAG_MASK_ERROR_BIT(tag & ~MPIR_Process.tagged_coll_mask)) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPIX_ERR_REVOKED,"**revoked");
}
MPIU_THREAD_CS_ENTER(MSGQUEUE,);
rreq = MPIDI_CH3U_Recvq_FDU_or_AEP(rank, tag,
comm->recvcontext_id + context_offset,
comm, buf, count, datatype, &found);
if (rreq == NULL) {
MPIU_THREAD_CS_EXIT(MSGQUEUE,);
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**nomemreq");
}
int MPID_Irecv(void * buf, int count, MPI_Datatype datatype, int rank, int tag,
MPID_Comm * comm, int context_offset,
MPID_Request ** request)
{
MPID_Request * rreq;
int found;
int mpi_errno = MPI_SUCCESS;
MPIDI_STATE_DECL(MPID_STATE_MPID_IRECV);
MPIDI_FUNC_ENTER(MPID_STATE_MPID_IRECV);
MPIU_DBG_MSG_FMT(CH3_OTHER,VERBOSE,(MPIU_DBG_FDEST,
"rank=%d, tag=%d, context=%d",
rank, tag, comm->recvcontext_id + context_offset));
if (rank == MPI_PROC_NULL)
{
rreq = MPID_Request_create();
if (rreq != NULL)
{
/* MT FIXME should these be handled by MPID_Request_create? */
MPIU_Object_set_ref(rreq, 1);
MPID_cc_set(&rreq->cc, 0);
rreq->kind = MPID_REQUEST_RECV;
MPIR_Status_set_procnull(&rreq->status);
}
else
{
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**nomemreq");
}
goto fn_exit;
}
MPIU_THREAD_CS_ENTER(MSGQUEUE,);
rreq = MPIDI_CH3U_Recvq_FDU_or_AEP(rank, tag,
comm->recvcontext_id + context_offset,
comm, buf, count, datatype, &found);
if (rreq == NULL)
{
MPIU_THREAD_CS_EXIT(MSGQUEUE,);
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**nomemreq");
}
int MPID_Mrecv(void *buf, int count, MPI_Datatype datatype,
MPIR_Request *message, MPI_Status *status, MPIR_Request **rreq)
{
int mpi_errno = MPI_SUCCESS;
*rreq = NULL;
if (message == NULL) {
/* treat as though MPI_MESSAGE_NO_PROC was passed */
MPIR_Status_set_procnull(status);
goto fn_exit;
}
/* There is no optimized MPID_Mrecv at this time because there is no real
* optimization potential in that case. MPID_Recv exists to prevent
* creating a request unnecessarily for messages that are already present
* and eligible for immediate completion. */
mpi_errno = MPID_Imrecv(buf, count, datatype, message, rreq);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
int MPID_Mprobe(int source, int tag, MPID_Comm *comm, int context_offset,
MPID_Request **message, MPI_Status *status)
{
int mpi_errno = MPI_SUCCESS;
MPID_Progress_state progress_state;
int found = FALSE;
int context_id = comm->recvcontext_id + context_offset;
*message = NULL;
if (source == MPI_PROC_NULL)
{
MPIR_Status_set_procnull(status);
found = TRUE;
*message = NULL; /* should be interpreted as MPI_MESSAGE_NO_PROC */
goto fn_exit;
}
/* Check to make sure the communicator hasn't already been revoked */
if (comm->revoked) {
MPIR_ERR_SETANDJUMP(mpi_errno,MPIX_ERR_REVOKED,"**revoked");
}
#ifdef ENABLE_COMM_OVERRIDES
if (MPIDI_Anysource_improbe_fn) {
if (source == MPI_ANY_SOURCE) {
/* if it's anysource, loop while checking the shm recv
queue and improbing the netmod, then do a progress
test to make some progress. */
do {
MPID_THREAD_CS_ENTER(POBJ, MPIR_THREAD_MSGQ_MUTEX);
*message = MPIDI_CH3U_Recvq_FDU_matchonly(source, tag, context_id, comm,&found);
MPID_THREAD_CS_EXIT(POBJ, MPIR_THREAD_MSGQ_MUTEX);
if (found) goto fn_exit;
mpi_errno = MPIDI_Anysource_improbe_fn(tag, comm, context_offset, &found, message, status);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
if (found) goto fn_exit;
MPID_THREAD_CS_YIELD(GLOBAL, MPIR_THREAD_GLOBAL_ALLFUNC_MUTEX);
/* FIXME could this be replaced with a progress_wait? */
mpi_errno = MPIDI_CH3_Progress_test();
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
} while (1);
}
else {
/* it's not anysource, see if this is for the netmod */
MPIDI_VC_t * vc;
MPIDI_Comm_get_vc_set_active(comm, source, &vc);
if (vc->comm_ops && vc->comm_ops->improbe) {
/* netmod has overridden improbe */
do {
mpi_errno = vc->comm_ops->improbe(vc, source, tag, comm, context_offset, &found,
message, status);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
if (found) goto fn_exit;
MPID_THREAD_CS_YIELD(GLOBAL, MPIR_THREAD_GLOBAL_ALLFUNC_MUTEX);
/* FIXME could this be replaced with a progress_wait? */
mpi_errno = MPIDI_CH3_Progress_test();
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
} while (1);
}
/* fall-through to shm case */
}
}
#endif
/* Inefficient implementation: we poll the unexpected queue looking for a
* matching request, interleaved with calls to progress. If there are many
* non-matching unexpected messages in the queue then we will end up
* needlessly scanning the UQ.
*
* A smarter implementation would enqueue a partial request (one lacking the
* recv buffer triple) onto the PQ. Unfortunately, this is a lot harder to
* do than it seems at first because of the spread-out nature of callers to
* various CH3U_Recvq routines and especially because of the enqueue/dequeue
* hooks for native MX tag matching support. */
MPIDI_CH3_Progress_start(&progress_state);
do
{
MPID_THREAD_CS_ENTER(POBJ, MPIR_THREAD_MSGQ_MUTEX);
*message = MPIDI_CH3U_Recvq_FDU_matchonly(source, tag, context_id, comm, &found);
MPID_THREAD_CS_EXIT(POBJ, MPIR_THREAD_MSGQ_MUTEX);
if (found)
break;
mpi_errno = MPIDI_CH3_Progress_wait(&progress_state);
}
while(mpi_errno == MPI_SUCCESS);
MPIDI_CH3_Progress_end(&progress_state);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
if (*message) {
(*message)->kind = MPID_REQUEST_MPROBE;
MPIR_Request_extract_status((*message), status);
}
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
int MPID_Probe(int source, int tag, MPID_Comm * comm, int context_offset,
MPI_Status * status)
{
MPID_Progress_state progress_state;
const int context = comm->recvcontext_id + context_offset;
int mpi_errno = MPI_SUCCESS;
MPIDI_STATE_DECL(MPID_STATE_MPID_PROBE);
MPIDI_FUNC_ENTER(MPID_STATE_MPID_PROBE);
if (source == MPI_PROC_NULL)
{
MPIR_Status_set_procnull(status);
goto fn_exit;
}
#ifdef ENABLE_COMM_OVERRIDES
if (MPIDI_Anysource_iprobe_fn) {
if (source == MPI_ANY_SOURCE) {
/* if it's anysource, loop while checking the shm recv
queue and iprobing the netmod, then do a progress
test to make some progress. */
do {
int found;
MPIU_THREAD_CS_ENTER(MSGQUEUE,);
found = MPIDI_CH3U_Recvq_FU(source, tag, context, status);
MPIU_THREAD_CS_EXIT(MSGQUEUE,);
if (found) goto fn_exit;
mpi_errno = MPIDI_Anysource_iprobe_fn(tag, comm, context_offset, &found, status);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
if (found) goto fn_exit;
MPIU_THREAD_CS_YIELD(ALLFUNC,);
mpi_errno = MPIDI_CH3_Progress_test();
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
} while (1);
} else {
/* it's not anysource, see if this is for the netmod */
MPIDI_VC_t * vc;
MPIDI_Comm_get_vc_set_active(comm, source, &vc);
if (vc->comm_ops && vc->comm_ops->iprobe) {
/* netmod has overridden iprobe */
do {
int found;
mpi_errno = vc->comm_ops->iprobe(vc, source, tag, comm, context_offset, &found,
status);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
if (found) goto fn_exit;
MPIU_THREAD_CS_YIELD(ALLFUNC,);
mpi_errno = MPIDI_CH3_Progress_test();
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
} while (1);
}
/* fall-through to shm case */
}
}
int MPID_Mprobe(int source, int tag, MPID_Comm *comm, int context_offset,
MPID_Request **message, MPI_Status *status)
{
int mpi_errno = MPI_SUCCESS;
MPID_Progress_state progress_state;
int found = FALSE;
int context_id = comm->recvcontext_id + context_offset;
*message = NULL;
if (source == MPI_PROC_NULL)
{
MPIR_Status_set_procnull(status);
found = TRUE;
*message = NULL; /* should be interpreted as MPI_MESSAGE_NO_PROC */
goto fn_exit;
}
/* Check to make sure the communicator hasn't already been revoked */
if (comm->revoked) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPIX_ERR_REVOKED,"**revoked");
}
#ifdef ENABLE_COMM_OVERRIDES
if (MPIDI_Anysource_improbe_fn) {
if (source == MPI_ANY_SOURCE) {
/* if it's anysource, loop while checking the shm recv
queue and improbing the netmod, then do a progress
test to make some progress. */
do {
MPIU_THREAD_CS_ENTER(MSGQUEUE,);
*message = MPIDI_CH3U_Recvq_FDU_matchonly(source, tag, context_id, comm,&found);
MPIU_THREAD_CS_EXIT(MSGQUEUE,);
if (found) goto fn_exit;
mpi_errno = MPIDI_Anysource_improbe_fn(tag, comm, context_offset, &found, message, status);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
if (found) goto fn_exit;
MPIU_THREAD_CS_YIELD(ALLFUNC,);
/* FIXME could this be replaced with a progress_wait? */
mpi_errno = MPIDI_CH3_Progress_test();
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
} while (1);
}
else {
/* it's not anysource, see if this is for the netmod */
MPIDI_VC_t * vc;
MPIDI_Comm_get_vc_set_active(comm, source, &vc);
if (vc->comm_ops && vc->comm_ops->improbe) {
/* netmod has overridden improbe */
do {
mpi_errno = vc->comm_ops->improbe(vc, source, tag, comm, context_offset, &found,
message, status);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
if (found) goto fn_exit;
MPIU_THREAD_CS_YIELD(ALLFUNC,);
/* FIXME could this be replaced with a progress_wait? */
mpi_errno = MPIDI_CH3_Progress_test();
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
} while (1);
}
/* fall-through to shm case */
}
}