/*@
MPI_Send - Performs a basic send
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 routine may block until the message is received.
.N fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_COMM
.N MPI_ERR_COUNT
.N MPI_ERR_TYPE
.N MPI_ERR_TAG
.N MPI_ERR_RANK
.seealso: MPI_Isend, MPI_Bsend
@*/
EXPORT_MPI_API int MPI_Send( void *buf, int count, MPI_Datatype datatype, int dest,
int tag, MPI_Comm comm )
{
int mpi_errno = MPI_SUCCESS;
struct MPIR_COMMUNICATOR *comm_ptr;
struct MPIR_DATATYPE *dtype_ptr;
static char myname[] = "MPI_SEND";
if (dest == MPI_PROC_NULL)
return MPI_SUCCESS;
comm_ptr = MPIR_GET_COMM_PTR(comm);
MPIR_TEST_MPI_COMM(comm,comm_ptr,comm_ptr,myname);
dtype_ptr = MPIR_GET_DTYPE_PTR(datatype);
MPIR_TEST_DTYPE(datatype,dtype_ptr,comm_ptr,myname);
#ifndef MPIR_NO_ERROR_CHECKING
MPIR_TEST_COUNT(count);
MPIR_TEST_SEND_TAG(tag);
MPIR_TEST_SEND_RANK(comm_ptr,dest);
if (mpi_errno)
return MPIR_ERROR(comm_ptr, mpi_errno, myname );
#endif
/* This COULD test for the contiguous homogeneous case first .... */
MPID_SendDatatype( comm_ptr, buf, count, dtype_ptr, comm_ptr->local_rank, tag,
comm_ptr->send_context, comm_ptr->lrank_to_grank[dest], &mpi_errno );
MPIR_RETURN(comm_ptr, mpi_errno, myname );
}
/*@
MPI_Issend - Starts a nonblocking synchronous send
Input Parameters:
+ buf - initial address of send buffer (choice)
. count - number of elements in send buffer (integer)
. datatype - datatype of each send buffer element (handle)
. dest - rank of destination (integer)
. tag - message tag (integer)
- comm - communicator (handle)
Output Parameter:
. request - communication request (handle)
.N fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_COMM
.N MPI_ERR_COUNT
.N MPI_ERR_TYPE
.N MPI_ERR_TAG
.N MPI_ERR_RANK
.N MPI_ERR_EXHAUSTED
@*/
int MPI_Issend( void *buf, int count, MPI_Datatype datatype, int dest,
int tag, MPI_Comm comm, MPI_Request *request )
{
struct MPIR_COMMUNICATOR *comm_ptr;
struct MPIR_DATATYPE *dtype_ptr;
MPIR_SHANDLE *shandle;
static char myname[] = "MPI_ISSEND";
int mpi_errno = MPI_SUCCESS;
disableSignal();
TR_PUSH(myname);
comm_ptr = MPIR_GET_COMM_PTR(comm);
MPIR_TEST_MPI_COMM(comm,comm_ptr,comm_ptr,myname);
dtype_ptr = MPIR_GET_DTYPE_PTR(datatype);
MPIR_TEST_DTYPE(datatype,dtype_ptr,comm_ptr,myname);
#ifndef MPIR_NO_ERROR_CHECKING
MPIR_TEST_COUNT(count);
MPIR_TEST_SEND_TAG(tag);
MPIR_TEST_SEND_RANK(comm_ptr,dest);
if (mpi_errno) {
revertSignal();
return MPIR_ERROR(comm_ptr, mpi_errno, myname );
}
#endif
MPIR_ALLOCFN(shandle,MPID_SendAlloc,
comm_ptr,MPI_ERR_EXHAUSTED,myname );
*request = (MPI_Request)shandle;
MPID_Request_init( shandle, MPIR_SEND );
MPIR_REMEMBER_SEND( shandle, buf, count, datatype, dest, tag, comm_ptr);
if (dest == MPI_PROC_NULL) {
shandle->is_complete = 1;
revertSignal();
return MPI_SUCCESS;
}
/* This COULD test for the contiguous homogeneous case first .... */
MPID_IssendDatatype( comm_ptr, buf, count, dtype_ptr,
comm_ptr->local_rank, tag,
comm_ptr->send_context,
comm_ptr->lrank_to_grank[dest],
*request, &mpi_errno );
if (mpi_errno) {
revertSignal();
return MPIR_ERROR( comm_ptr, mpi_errno, myname );
}
TR_POP;
revertSignal();
return MPI_SUCCESS;
}
/*@
MPI_Ssend_init - Builds a handle for a synchronous send
Input Parameters:
+ buf - initial address of send buffer (choice)
. count - number of elements sent (integer)
. datatype - type of each element (handle)
. dest - rank of destination (integer)
. tag - message tag (integer)
- comm - communicator (handle)
Output Parameter:
. request - communication request (handle)
.N fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_COMM
.N MPI_ERR_COUNT
.N MPI_ERR_TYPE
.N MPI_ERR_TAG
.N MPI_ERR_RANK
@*/
int MPI_Ssend_init( void *buf, int count, MPI_Datatype datatype, int dest,
int tag, MPI_Comm comm, MPI_Request *request )
{
int mpi_errno = MPI_SUCCESS;
struct MPIR_DATATYPE *dtype_ptr;
struct MPIR_COMMUNICATOR *comm_ptr;
static char myname[] = "MPI_SSEND_INIT";
MPIR_PSHANDLE *shandle;
disableSignal();
TR_PUSH(myname);
comm_ptr = MPIR_GET_COMM_PTR(comm);
MPIR_TEST_MPI_COMM(comm,comm_ptr,comm_ptr,myname);
#ifndef MPIR_NO_ERROR_CHECKING
MPIR_TEST_COUNT(count);
MPIR_TEST_SEND_TAG(tag);
MPIR_TEST_SEND_RANK(comm_ptr,dest);
if (mpi_errno) {
revertSignal();
return MPIR_ERROR(comm_ptr, mpi_errno, myname );
}
#endif
/* This is IDENTICAL to the create_send code except for the send
function */
MPIR_ALLOCFN(shandle,MPID_PSendAlloc,
comm_ptr,MPI_ERR_EXHAUSTED,myname );
*request = (MPI_Request)shandle;
MPID_Request_init( &(shandle->shandle), MPIR_PERSISTENT_SEND );
/* Save the information about the operation, being careful with
ref-counted items */
dtype_ptr = MPIR_GET_DTYPE_PTR(datatype);
MPIR_TEST_DTYPE(datatype,dtype_ptr,comm_ptr,myname);
MPIR_REF_INCR(dtype_ptr);
shandle->perm_datatype = dtype_ptr;
shandle->perm_tag = tag;
shandle->perm_dest = dest;
shandle->perm_count = count;
shandle->perm_buf = buf;
MPIR_REF_INCR(comm_ptr);
shandle->perm_comm = comm_ptr;
shandle->active = 0;
shandle->send = MPID_IssendDatatype;
/* dest of MPI_PROC_NULL handled in start */
TR_POP;
revertSignal();
return MPI_SUCCESS;
}
/*@
MPI_Irsend - Starts a nonblocking ready send
Input Parameters:
+ buf - initial address of send buffer (choice)
. count - number of elements in send buffer (integer)
. datatype - datatype of each send buffer element (handle)
. dest - rank of destination (integer)
. tag - message tag (integer)
- comm - communicator (handle)
Output Parameter:
. request - communication request (handle)
.N fortran
.N Errors
.N MPI_SUCCESS
.N MPI_ERR_COMM
.N MPI_ERR_COUNT
.N MPI_ERR_TYPE
.N MPI_ERR_TAG
.N MPI_ERR_RANK
.N MPI_ERR_EXHAUSTED
@*/
EXPORT_MPI_API int MPI_Irsend( void *buf, int count, MPI_Datatype datatype, int dest,
int tag, MPI_Comm comm, MPI_Request *request )
{
struct MPIR_COMMUNICATOR *comm_ptr;
struct MPIR_DATATYPE *dtype_ptr;
MPIR_SHANDLE *shandle;
static char myname[] = "MPI_IRSEND";
int mpi_errno = MPI_SUCCESS;
TR_PUSH(myname);
comm_ptr = MPIR_GET_COMM_PTR(comm);
MPIR_TEST_MPI_COMM(comm,comm_ptr,comm_ptr,myname);
dtype_ptr = MPIR_GET_DTYPE_PTR(datatype);
MPIR_TEST_DTYPE(datatype,dtype_ptr,comm_ptr,myname);
#ifndef MPIR_NO_ERROR_CHECKING
MPIR_TEST_COUNT(count);
MPIR_TEST_SEND_TAG(tag);
MPIR_TEST_SEND_RANK(comm_ptr,dest);
if (mpi_errno)
return MPIR_ERROR(comm_ptr, mpi_errno, myname );
#endif
MPIR_ALLOCFN(shandle,MPID_Send_alloc,
comm_ptr,MPI_ERR_EXHAUSTED,myname );
*request = (MPI_Request)shandle;
MPID_Request_init( (MPI_Request)shandle, MPIR_SEND );
/* we need the rank of dest in MPI_COMM_ALL in MPID_Gateway_SendCancelPacket(),
so we save it here */
shandle->partner_grank = comm_ptr->lrank_to_grank[dest];
MPIR_REMEMBER_SEND(shandle, buf, count, datatype, dest, tag, comm_ptr);
if (dest == MPI_PROC_NULL) {
shandle->is_complete = 1;
return MPI_SUCCESS;
}
/* This COULD test for the contiguous homogeneous case first .... */
MPID_IrsendDatatype( comm_ptr, buf, count, dtype_ptr,
comm_ptr->local_rank, tag,
comm_ptr->send_context,
comm_ptr->lrank_to_grank[dest],
*request, &mpi_errno, 1 );
if (mpi_errno) return MPIR_ERROR( comm_ptr, mpi_errno, myname );
TR_POP;
return MPI_SUCCESS;
}
/*@
MPI_Bsend - Basic send with user-specified 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 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(
void *buf,
int count,
MPI_Datatype datatype,
int dest,
int tag,
MPI_Comm comm )
{
MPI_Request handle;
MPI_Status status;
int mpi_errno = MPI_SUCCESS;
struct MPIR_COMMUNICATOR *comm_ptr;
MPIR_ERROR_DECL;
static char myname[] = "MPI_BSEND";
disableSignal();
TR_PUSH(myname);
if (dest != MPI_PROC_NULL)
{
/* We should let Ibsend find the errors, but
we will soon add a special case for faster Bsend and we'll
need these tests then
*/
comm_ptr = MPIR_GET_COMM_PTR(comm);
#ifndef MPIR_NO_ERROR_CHECKING
MPIR_TEST_MPI_COMM(comm,comm_ptr,comm_ptr,myname);
MPIR_TEST_COUNT(count);
MPIR_TEST_SEND_TAG(tag);
MPIR_TEST_SEND_RANK(comm_ptr,dest);
if (mpi_errno) {
revertSignal();
return MPIR_ERROR(comm_ptr, mpi_errno, myname );
}
#endif
/*
? BsendDatatype?
MPID_BsendContig( comm, buf, len, src_lrank, tag, context_id,
dest_grank, msgrep, &mpi_errno );
if (!mpi_errno) return MPI_SUCCESS;
if (mpi_errno != MPIR_ERR_MAY_BLOCK)
return MPIR_ERROR( comm, mpi_errno, myname );
*/
MPIR_ERROR_PUSH(comm_ptr);
/* We don't use MPIR_CALL_POP so that we can free the handle */
handle = MPI_REQUEST_NULL;
if ((mpi_errno = MPI_Ibsend( buf, count, datatype, dest, tag, comm,
&handle ))) {
MPIR_ERROR_POP(comm_ptr);
if (handle != MPI_REQUEST_NULL)
MPID_SendFree( handle );
revertSignal();
return MPIR_ERROR(comm_ptr,mpi_errno,myname);
}
/* This Wait only completes the transfer of data into the
buffer area. The test/wait in util/bsendutil.c completes
the actual transfer
*/
MPIR_CALL_POP(MPI_Wait( &handle, &status ),comm_ptr,myname);
MPIR_ERROR_POP(comm_ptr);
}
TR_POP;
revertSignal();
return mpi_errno;
}