int MPIR_Ibsend_impl(const void *buf, int count, MPI_Datatype datatype, int dest, int tag,
MPIR_Comm * comm_ptr, MPI_Request * request)
{
int mpi_errno = MPI_SUCCESS;
MPIR_Request *request_ptr, *new_request_ptr;
ibsend_req_info *ibinfo = 0;
/* We don't try tbsend in for MPI_Ibsend because we must create a
* request even if we can send the message */
mpi_errno = MPIR_Bsend_isend(buf, count, datatype, dest, tag, comm_ptr, IBSEND, &request_ptr);
if (mpi_errno != MPI_SUCCESS)
goto fn_fail;
MPII_SENDQ_REMEMBER(request_ptr, dest, tag, comm_ptr->context_id);
/* FIXME: use the memory management macros */
ibinfo = (ibsend_req_info *) MPL_malloc(sizeof(ibsend_req_info), MPL_MEM_BUFFER);
ibinfo->req = request_ptr;
ibinfo->cancelled = 0;
mpi_errno = MPIR_Grequest_start(MPIR_Ibsend_query, MPIR_Ibsend_free,
MPIR_Ibsend_cancel, ibinfo, &new_request_ptr);
if (mpi_errno)
MPIR_ERR_POP(mpi_errno);
/* The request is immediately complete because the MPIR_Bsend_isend has
* already moved the data out of the user's buffer */
MPIR_Grequest_complete(new_request_ptr);
MPIR_OBJ_PUBLISH_HANDLE(*request, new_request_ptr->handle);
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
/*@
MPI_Bsend - Basic send with user-provided buffering
Input Parameters:
+ buf - initial address of send buffer (choice)
. count - number of elements in send buffer (nonnegative integer)
. datatype - datatype of each send buffer element (handle)
. dest - rank of destination (integer)
. tag - message tag (integer)
- comm - communicator (handle)
Notes:
This send is provided as a convenience function; it allows the user to
send messages without worring about where they are buffered (because the
user `must` have provided buffer space with 'MPI_Buffer_attach').
In deciding how much buffer space to allocate, remember that the buffer space
is not available for reuse by subsequent 'MPI_Bsend's unless you are certain
that the message
has been received (not just that it should have been received). For example,
this code does not allocate enough buffer space
.vb
MPI_Buffer_attach( b, n*sizeof(double) + MPI_BSEND_OVERHEAD );
for (i=0; i<m; i++) {
MPI_Bsend( buf, n, MPI_DOUBLE, ... );
}
.ve
because only enough buffer space is provided for a single send, and the
loop may start a second 'MPI_Bsend' before the first is done making use of the
buffer.
In C, you can
force the messages to be delivered by
.vb
MPI_Buffer_detach( &b, &n );
MPI_Buffer_attach( b, n );
.ve
(The 'MPI_Buffer_detach' will not complete until all buffered messages are
delivered.)
.N ThreadSafe
.N Fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_COMM
.N MPI_ERR_COUNT
.N MPI_ERR_TYPE
.N MPI_ERR_RANK
.N MPI_ERR_TAG
.seealso: MPI_Buffer_attach, MPI_Ibsend, MPI_Bsend_init
@*/
int MPI_Bsend(const void *buf, int count, MPI_Datatype datatype, int dest, int tag,
MPI_Comm comm)
{
static const char FCNAME[] = "MPI_Bsend";
int mpi_errno = MPI_SUCCESS;
MPID_Comm *comm_ptr = NULL;
MPID_Request *request_ptr = NULL;
MPID_MPI_STATE_DECL(MPID_STATE_MPI_BSEND);
MPIR_ERRTEST_INITIALIZED_ORDIE();
MPID_THREAD_CS_ENTER(GLOBAL, MPIR_THREAD_GLOBAL_ALLFUNC_MUTEX);
MPID_MPI_PT2PT_FUNC_ENTER_FRONT(MPID_STATE_MPI_BSEND);
/* Validate handle parameters needing to be converted */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPIR_ERRTEST_COMM(comm, mpi_errno);
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* Convert MPI object handles to object pointers */
MPID_Comm_get_ptr( comm, comm_ptr );
/* Validate object pointers if error checking is enabled */
# ifdef HAVE_ERROR_CHECKING
{
MPID_BEGIN_ERROR_CHECKS;
{
MPIR_ERRTEST_COUNT(count,mpi_errno);
/* Validate comm_ptr */
MPID_Comm_valid_ptr( comm_ptr, mpi_errno, FALSE );
if (mpi_errno) goto fn_fail;
/* If comm_ptr is not valid, it will be reset to null */
if (comm_ptr) {
MPIR_ERRTEST_SEND_TAG(tag,mpi_errno);
MPIR_ERRTEST_SEND_RANK(comm_ptr,dest,mpi_errno)
}
/* Validate datatype handle */
MPIR_ERRTEST_DATATYPE(datatype, "datatype", mpi_errno);
/* Validate datatype object */
if (HANDLE_GET_KIND(datatype) != HANDLE_KIND_BUILTIN)
{
MPID_Datatype *datatype_ptr = NULL;
MPID_Datatype_get_ptr(datatype, datatype_ptr);
MPID_Datatype_valid_ptr(datatype_ptr, mpi_errno);
if (mpi_errno) goto fn_fail;
MPID_Datatype_committed_ptr(datatype_ptr, mpi_errno);
if (mpi_errno) goto fn_fail;
}
/* Validate buffer */
MPIR_ERRTEST_USERBUFFER(buf,count,datatype,mpi_errno);
}
MPID_END_ERROR_CHECKS;
}
# endif /* HAVE_ERROR_CHECKING */
/* ... body of routine ... */
# ifdef MPID_HAS_TBSEND
{
mpi_errno = MPID_tBsend( buf, count, datatype, dest, tag, comm_ptr, 0 );
if (mpi_errno == MPI_SUCCESS)
{
goto fn_exit;
}
/* FIXME: Check for MPID_WOULD_BLOCK? */
}
# endif
mpi_errno = MPIR_Bsend_isend( buf, count, datatype, dest, tag, comm_ptr,
BSEND, &request_ptr );
/* Note that we can ignore the request_ptr because it is handled internally
by the bsend util routines */
if (mpi_errno != MPI_SUCCESS) goto fn_fail;
/* ... end of body of routine ... */
fn_exit:
MPID_MPI_PT2PT_FUNC_EXIT(MPID_STATE_MPI_BSEND);
MPID_THREAD_CS_EXIT(GLOBAL, MPIR_THREAD_GLOBAL_ALLFUNC_MUTEX);
return mpi_errno;
fn_fail:
/* --BEGIN ERROR HANDLING-- */
# ifdef HAVE_ERROR_CHECKING
{
mpi_errno = MPIR_Err_create_code(
mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**mpi_bsend",
"**mpi_bsend %p %d %D %i %t %C", buf, count, datatype, dest, tag, comm);
}
# endif
mpi_errno = MPIR_Err_return_comm( comm_ptr, FCNAME, mpi_errno );
goto fn_exit;
/* --END ERROR HANDLING-- */
}
int MPID_Startall(int count, MPID_Request * requests[])
{
int rc=MPI_SUCCESS, i;
for (i = 0; i < count; i++)
{
MPID_Request * const preq = requests[i];
switch(MPID_Request_getType(preq))
{
case MPIDI_DCMF_REQUEST_TYPE_RECV:
{
rc = MPID_Irecv(preq->dcmf.userbuf,
preq->dcmf.userbufcount,
preq->dcmf.datatype,
MPID_Request_getMatchRank(preq),
MPID_Request_getMatchTag(preq),
preq->comm,
MPID_Request_getMatchCtxt(preq) - preq->comm->recvcontext_id,
&preq->partner_request);
break;
}
case MPIDI_DCMF_REQUEST_TYPE_SEND:
{
rc = MPID_Isend(preq->dcmf.userbuf,
preq->dcmf.userbufcount,
preq->dcmf.datatype,
MPID_Request_getMatchRank(preq),
MPID_Request_getMatchTag(preq),
preq->comm,
MPID_Request_getMatchCtxt(preq) - preq->comm->context_id,
&preq->partner_request);
break;
}
case MPIDI_DCMF_REQUEST_TYPE_RSEND:
{
rc = MPID_Irsend(preq->dcmf.userbuf,
preq->dcmf.userbufcount,
preq->dcmf.datatype,
MPID_Request_getMatchRank(preq),
MPID_Request_getMatchTag(preq),
preq->comm,
MPID_Request_getMatchCtxt(preq) - preq->comm->context_id,
&preq->partner_request);
break;
}
case MPIDI_DCMF_REQUEST_TYPE_SSEND:
{
rc = MPID_Issend(preq->dcmf.userbuf,
preq->dcmf.userbufcount,
preq->dcmf.datatype,
MPID_Request_getMatchRank(preq),
MPID_Request_getMatchTag(preq),
preq->comm,
MPID_Request_getMatchCtxt(preq) - preq->comm->context_id,
&preq->partner_request);
break;
}
case MPIDI_DCMF_REQUEST_TYPE_BSEND:
{
rc = MPIR_Bsend_isend(preq->dcmf.userbuf,
preq->dcmf.userbufcount,
preq->dcmf.datatype,
MPID_Request_getMatchRank(preq),
MPID_Request_getMatchTag(preq),
preq->comm,
BSEND_INIT,
&preq->partner_request);
/*
* MPICH2 maintains an independant reference to the child,
* but doesn't refcount it. Since they actually call
* MPI_Test() on the child request (which will release a
* ref iff the request is complete), we have to increment
* the ref_count so that it doesn't get freed from under
* us.
*/
if (preq->partner_request != NULL)
MPIU_Object_add_ref(preq->partner_request);
break;
}
default:
{
rc = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_FATAL, "MPID_Startall", __LINE__, MPI_ERR_INTERN,"**ch3|badreqtype","**ch3|badreqtype %d",MPID_Request_getType(preq));
}
} /* switch should end here, bug fixed. */
if (rc == MPI_SUCCESS)
{
preq->status.MPI_ERROR = MPI_SUCCESS;
if (MPID_Request_getType(preq) == MPIDI_DCMF_REQUEST_TYPE_BSEND)
{
/*
* Complete a persistent Bsend immediately.
*
* Because the child of a persistent Bsend is just a
* normal Isend on a temp buffer, we don't need to wait on
* the child when the user calls MPI_Wait on the parent.
* Therefore, disconnect the cc_ptr link to the child and
* mark the parent complete.
*/
preq->cc = 0;
preq->cc_ptr = &preq->cc;
}
else
preq->cc_ptr = &preq->partner_request->cc;
}
else
{
/* If a failure occurs attempting to start the request,
then we assume that partner request was not created,
and stuff the error code in the persistent request.
The wait and test routines will look at the error code
in the persistent request if a partner request is not present. */
preq->partner_request = NULL;
preq->status.MPI_ERROR = rc;
preq->cc_ptr = &preq->cc;
preq->cc = 0;
}
} /* for */
return rc;
}
