int MPIDI_CH3U_Handle_ordered_recv_pkt(MPIDI_VC_t * vc, MPIDI_CH3_Pkt_t * pkt,
MPIDI_msg_sz_t *buflen, MPID_Request ** rreqp)
{
int mpi_errno = MPI_SUCCESS;
static MPIDI_CH3_PktHandler_Fcn *pktArray[MPIDI_CH3_PKT_END_CH3+1];
static int needsInit = 1;
MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3U_HANDLE_ORDERED_RECV_PKT);
MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3U_HANDLE_ORDERED_RECV_PKT);
MPIU_DBG_STMT(CH3_OTHER,VERBOSE,MPIDI_DBG_Print_packet(pkt));
/* FIXME: We can turn this into something like
MPIU_Assert(pkt->type <= MAX_PACKET_TYPE);
mpi_errno = MPIDI_CH3_ProgressFunctions[pkt->type](vc,pkt,rreqp);
in the progress engine itself. Then this routine is not necessary.
*/
if (needsInit) {
MPIDI_CH3_PktHandler_Init( pktArray, MPIDI_CH3_PKT_END_CH3 );
needsInit = 0;
}
/* Packet type is an enum and hence >= 0 */
MPIU_Assert(pkt->type <= MPIDI_CH3_PKT_END_CH3);
mpi_errno = pktArray[pkt->type](vc, pkt, buflen, rreqp);
MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_CH3U_HANDLE_ORDERED_RECV_PKT);
return mpi_errno;
}
int MPIDI_CH3_iStartMsg(MPIDI_VC_t * vc, void * hdr, MPIDI_msg_sz_t hdr_sz,
MPID_Request ** sreq_ptr)
{
MPID_Request * sreq = NULL;
MPIDI_CH3I_VC *vcch = &vc->ch;
int mpi_errno = MPI_SUCCESS;
MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3_ISTARTMSG);
MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3_ISTARTMSG);
MPIU_Assert( hdr_sz <= sizeof(MPIDI_CH3_Pkt_t));
/* The SOCK channel uses a fixed length header, the size of which is the
maximum of all possible packet headers */
hdr_sz = sizeof(MPIDI_CH3_Pkt_t);
MPIU_DBG_STMT(CH3_CHANNEL,VERBOSE,
MPIDI_DBG_Print_packet((MPIDI_CH3_Pkt_t*)hdr));
if (vcch->state == MPIDI_CH3I_VC_STATE_CONNECTED) /* MT */
{
/* Connection already formed. If send queue is empty attempt to send
data, queuing any unsent data. */
if (MPIDI_CH3I_SendQ_empty(vcch)) /* MT */
{
MPIU_Size_t nb;
int rc;
MPIU_DBG_MSG(CH3_CHANNEL,VERBOSE,
"send queue empty, attempting to write");
MPIU_DBG_PKT(vcch->conn,hdr,"istartmsg");
/* MT: need some signalling to lock down our right to use the
channel, thus insuring that the progress engine does
not also try to write */
rc = MPIDU_Sock_write(vcch->sock, hdr, hdr_sz, &nb);
if (rc == MPI_SUCCESS)
{
MPIU_DBG_MSG_D(CH3_CHANNEL,VERBOSE,
"wrote %ld bytes", (unsigned long) nb);
if (nb == hdr_sz)
{
MPIU_DBG_MSG_D(CH3_CHANNEL,VERBOSE,
"entire write complete, " MPIDI_MSG_SZ_FMT " bytes", nb);
/* done. get us out of here as quickly as possible. */
}
else
{
MPIU_DBG_MSG_D(CH3_CHANNEL,VERBOSE,
"partial write of " MPIDI_MSG_SZ_FMT " bytes, request enqueued at head", nb);
sreq = create_request(hdr, hdr_sz, nb);
if (!sreq) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**nomem");
}
MPIDI_CH3I_SendQ_enqueue_head(vcch, sreq);
MPIU_DBG_MSG_FMT(CH3_CHANNEL,VERBOSE,
(MPIU_DBG_FDEST,"posting write, vc=0x%p, sreq=0x%08x", vc, sreq->handle));
vcch->conn->send_active = sreq;
mpi_errno = MPIDU_Sock_post_write(vcch->conn->sock, sreq->dev.iov[0].MPID_IOV_BUF,
sreq->dev.iov[0].MPID_IOV_LEN, sreq->dev.iov[0].MPID_IOV_LEN, NULL);
/* --BEGIN ERROR HANDLING-- */
if (mpi_errno != MPI_SUCCESS)
{
mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER,
"**ch3|sock|postwrite", "ch3|sock|postwrite %p %p %p",
sreq, vcch->conn, vc);
goto fn_fail;
}
/* --END ERROR HANDLING-- */
}
}
/* --BEGIN ERROR HANDLING-- */
else
{
MPIU_DBG_MSG_D(CH3_CHANNEL,TYPICAL,
"ERROR - MPIDU_Sock_write failed, rc=%d", rc);
sreq = MPID_Request_create();
if (!sreq) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**nomem");
}
sreq->kind = MPID_REQUEST_SEND;
MPID_cc_set(&(sreq->cc), 0);
sreq->status.MPI_ERROR = MPIR_Err_create_code( rc,
MPIR_ERR_RECOVERABLE, FCNAME, __LINE__,
MPI_ERR_INTERN, "**ch3|sock|writefailed",
"**ch3|sock|writefailed %d", rc );
/* Make sure that the caller sees this error */
mpi_errno = sreq->status.MPI_ERROR;
}
/* --END ERROR HANDLING-- */
}
else
{
MPIU_DBG_MSG(CH3_CHANNEL,VERBOSE,
"send in progress, request enqueued");
sreq = create_request(hdr, hdr_sz, 0);
if (!sreq) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**nomem");
}
MPIDI_CH3I_SendQ_enqueue(vcch, sreq);
}
}
else if (vcch->state == MPIDI_CH3I_VC_STATE_CONNECTING) /* MT */
{
MPIU_DBG_VCUSE(vc,
"connecteding. enqueuing request");
/* queue the data so it can be sent after the connection is formed */
sreq = create_request(hdr, hdr_sz, 0);
if (!sreq) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**nomem");
}
MPIDI_CH3I_SendQ_enqueue(vcch, sreq);
}
else if (vcch->state == MPIDI_CH3I_VC_STATE_UNCONNECTED) /* MT */
{
MPIU_DBG_VCUSE(vc,
"unconnected. posting connect and enqueuing request");
/* queue the data so it can be sent after the connection is formed */
sreq = create_request(hdr, hdr_sz, 0);
if (!sreq) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**nomem");
}
MPIDI_CH3I_SendQ_enqueue(vcch, sreq);
/* Form a new connection */
MPIDI_CH3I_VC_post_connect(vc);
}
else if (vcch->state != MPIDI_CH3I_VC_STATE_FAILED)
{
/* Unable to send data at the moment, so queue it for later */
MPIU_DBG_VCUSE(vc,"forming connection, request enqueued");
sreq = create_request(hdr, hdr_sz, 0);
if (!sreq) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**nomem");
}
MPIDI_CH3I_SendQ_enqueue(vcch, sreq);
}
/* --BEGIN ERROR HANDLING-- */
else
{
/* Connection failed, so allocate a request and return an error. */
MPIU_DBG_VCUSE(vc,"ERROR - connection failed");
sreq = MPID_Request_create();
if (!sreq) {
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**nomem");
}
sreq->kind = MPID_REQUEST_SEND;
MPID_cc_set(&sreq->cc, 0);
sreq->status.MPI_ERROR = MPIR_Err_create_code( MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, FCNAME, __LINE__,
MPI_ERR_INTERN, "**ch3|sock|connectionfailed",0 );
/* Make sure that the caller sees this error */
mpi_errno = sreq->status.MPI_ERROR;
}
/* --END ERROR HANDLING-- */
fn_fail:
*sreq_ptr = sreq;
MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_CH3_ISTARTMSG);
return mpi_errno;
}
/*
* Carve off size bytes from buffer p and leave the remainder
* on the avail list. Handle the head/tail cases.
* If there isn't enough left of p, remove the entire segment from
* the avail list.
*/
static void MPIR_Bsend_take_buffer( MPIR_Bsend_data_t *p, int size )
{
MPIR_Bsend_data_t *prev;
int alloc_size;
/* Compute the remaining size. This must include any padding
that must be added to make the new block properly aligned */
alloc_size = size;
if (alloc_size & 0x7)
alloc_size += (8 - (alloc_size & 0x7));
/* alloc_size is the amount of space (out of size) that we will
allocate for this buffer. */
MPIU_DBG_MSG_FMT(BSEND,TYPICAL,(MPIU_DBG_FDEST,
"Taking %d bytes from a block with %llu bytes\n",
alloc_size, (unsigned long long) p->total_size ));
/* Is there enough space left to create a new block? */
if (alloc_size + (int)BSENDDATA_HEADER_TRUE_SIZE + MIN_BUFFER_BLOCK <= p->size) {
/* Yes, the available space (p->size) is large enough to
carve out a new block */
MPIR_Bsend_data_t *newp;
MPIU_DBG_MSG_P(BSEND,TYPICAL,"Breaking block into used and allocated at %p", p );
newp = (MPIR_Bsend_data_t *)( (char *)p + BSENDDATA_HEADER_TRUE_SIZE +
alloc_size );
newp->total_size = p->total_size - alloc_size -
BSENDDATA_HEADER_TRUE_SIZE;
newp->size = newp->total_size - BSENDDATA_HEADER_TRUE_SIZE;
newp->msg.msgbuf = (char *)newp + BSENDDATA_HEADER_TRUE_SIZE;
/* Insert this new block after p (we'll remove p from the avail list
next) */
newp->next = p->next;
newp->prev = p;
if (p->next) {
p->next->prev = newp;
}
p->next = newp;
p->total_size = (char *)newp - (char*)p;
p->size = p->total_size - BSENDDATA_HEADER_TRUE_SIZE;
MPIU_DBG_MSG_FMT(BSEND,TYPICAL,(MPIU_DBG_FDEST,
"broken blocks p (%llu) and new (%llu)\n",
(unsigned long long) p->total_size,
(unsigned long long) newp->total_size ));
}
/* Remove p from the avail list and add it to the active list */
prev = p->prev;
if (prev) {
prev->next = p->next;
}
else {
BsendBuffer.avail = p->next;
}
if (p->next) {
p->next->prev = p->prev;
}
if (BsendBuffer.active) {
BsendBuffer.active->prev = p;
}
p->next = BsendBuffer.active;
p->prev = 0;
BsendBuffer.active = p;
MPIU_DBG_MSG_P(BSEND,VERBOSE,"segment %p now head of active",p);
MPIU_DBG_MSG(BSEND,TYPICAL,"At end of take buffer" );
MPIU_DBG_STMT(BSEND,TYPICAL,MPIR_Bsend_dump());
}
static void MPIR_Bsend_free_segment( MPIR_Bsend_data_t *p )
{
MPIR_Bsend_data_t *prev = p->prev, *avail = BsendBuffer.avail, *avail_prev;
MPIU_DBG_MSG_FMT(BSEND,TYPICAL,(MPIU_DBG_FDEST,
"Freeing bsend segment at %p of size %llu, next at %p",
p, (unsigned long long) p->size, ((char *)p)+p->total_size));
MPIU_DBG_MSG_D(BSEND,TYPICAL,
"At the begining of free_segment with size %llu:",
(unsigned long long) p->total_size );
MPIU_DBG_STMT(BSEND,TYPICAL,MPIR_Bsend_dump());
/* Remove the segment from the active list */
if (prev) {
MPIU_DBG_MSG(BSEND,TYPICAL,"free segment is within active list");
prev->next = p->next;
}
else {
/* p was at the head of the active list */
MPIU_DBG_MSG(BSEND,TYPICAL,"free segment is head of active list");
BsendBuffer.active = p->next;
/* The next test sets the prev pointer to null */
}
if (p->next) {
p->next->prev = prev;
}
MPIU_DBG_STMT(BSEND,VERBOSE,MPIR_Bsend_dump());
/* Merge into the avail list */
/* Find avail_prev, avail, such that p is between them.
either may be null if p is at either end of the list */
avail_prev = 0;
while (avail) {
if (avail > p) {
break;
}
avail_prev = avail;
avail = avail->next;
}
/* Try to merge p with the next block */
if (avail) {
if ((char *)p + p->total_size == (char *)avail) {
p->total_size += avail->total_size;
p->size = p->total_size - BSENDDATA_HEADER_TRUE_SIZE;
p->next = avail->next;
if (avail->next) avail->next->prev = p;
avail = 0;
}
else {
p->next = avail;
avail->prev = p;
}
}
else {
p->next = 0;
}
/* Try to merge p with the previous block */
if (avail_prev) {
if ((char *)avail_prev + avail_prev->total_size == (char *)p) {
avail_prev->total_size += p->total_size;
avail_prev->size = avail_prev->total_size - BSENDDATA_HEADER_TRUE_SIZE;
avail_prev->next = p->next;
if (p->next) p->next->prev = avail_prev;
}
else {
avail_prev->next = p;
p->prev = avail_prev;
}
}
else {
/* p is the new head of the list */
BsendBuffer.avail = p;
p->prev = 0;
}
MPIU_DBG_MSG(BSEND,TYPICAL,"At the end of free_segment:" );
MPIU_DBG_STMT(BSEND,TYPICAL,MPIR_Bsend_dump());
}
int MPIR_Bsend_isend(const void *buf, int count, MPI_Datatype dtype,
int dest, int tag, MPID_Comm *comm_ptr,
MPIR_Bsend_kind_t kind, MPID_Request **request )
{
int mpi_errno = MPI_SUCCESS;
MPIR_Bsend_data_t *p;
MPIR_Bsend_msg_t *msg;
int packsize, pass;
/* Find a free segment and copy the data into it. If we could
have, we would already have used tBsend to send the message with
no copying.
We may want to decide here whether we need to pack at all
or if we can just use (a MPIU_Memcpy) of the buffer.
*/
/* We check the active buffer first. This helps avoid storage
fragmentation */
mpi_errno = MPIR_Bsend_check_active();
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
if (dtype != MPI_PACKED)
MPIR_Pack_size_impl( count, dtype, &packsize );
else
packsize = count;
MPIU_DBG_MSG_D(BSEND,TYPICAL,"looking for buffer of size %d", packsize);
/*
* Use two passes. Each pass is the same; between the two passes,
* attempt to complete any active requests, and start any pending
* ones. If the message can be initiated in the first pass,
* do not perform the second pass.
*/
for (pass = 0; pass < 2; pass++) {
p = MPIR_Bsend_find_buffer( packsize );
if (p) {
MPIU_DBG_MSG_FMT(BSEND,TYPICAL,(MPIU_DBG_FDEST,
"found buffer of size %d with address %p",packsize,p));
/* Found a segment */
msg = &p->msg;
/* Pack the data into the buffer */
/* We may want to optimize for the special case of
either primative or contiguous types, and just
use MPIU_Memcpy and the provided datatype */
msg->count = 0;
if (dtype != MPI_PACKED)
{
mpi_errno = MPIR_Pack_impl( buf, count, dtype, p->msg.msgbuf, packsize, &p->msg.count);
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
}
else
{
MPIU_Memcpy(p->msg.msgbuf, buf, count);
p->msg.count = count;
}
/* Try to send the message. We must use MPID_Isend
because this call must not block */
mpi_errno = MPID_Isend(msg->msgbuf, msg->count, MPI_PACKED,
dest, tag, comm_ptr,
MPID_CONTEXT_INTRA_PT2PT, &p->request );
MPIU_ERR_CHKINTERNAL(mpi_errno, mpi_errno, "Bsend internal error: isend returned err");
/* If the error is "request not available", we should
put this on the pending list. This will depend on
how we signal failure to send. */
if (p->request) {
MPIU_DBG_MSG_FMT(BSEND,TYPICAL,
(MPIU_DBG_FDEST,"saving request %p in %p",p->request,p));
/* An optimization is to check to see if the
data has already been sent. The original code
to do this was commented out and probably did not match
the current request internals */
MPIR_Bsend_take_buffer( p, p->msg.count );
p->kind = kind;
*request = p->request;
}
break;
}
/* If we found a buffer or we're in the seccond pass, then break.
Note that the test on phere is redundant, as the code breaks
out of the loop in the test above if a block p is found. */
if (p || pass == 1) break;
MPIU_DBG_MSG(BSEND,TYPICAL,"Could not find storage, checking active");
/* Try to complete some pending bsends */
MPIR_Bsend_check_active( );
/* Give priority to any pending operations */
MPIR_Bsend_retry_pending( );
}
if (!p) {
/* Return error for no buffer space found */
/* Generate a traceback of the allocated space, explaining why
packsize could not be found */
MPIU_DBG_MSG(BSEND,TYPICAL,"Could not find space; dumping arena" );
MPIU_DBG_STMT(BSEND,TYPICAL,MPIR_Bsend_dump());
MPIU_ERR_SETANDJUMP2(mpi_errno, MPI_ERR_BUFFER, "**bufbsend", "**bufbsend %d %d", packsize, BsendBuffer.buffer_size);
}
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
int MPIDI_CH3_iSendv(MPIDI_VC_t * vc, MPID_Request * sreq,
MPID_IOV * iov, int n_iov)
{
int mpi_errno = MPI_SUCCESS;
MPIDI_CH3I_VC *vcch = &vc->ch;
int (*reqFn)(MPIDI_VC_t *, MPID_Request *, int *);
MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3_ISENDV);
MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3_ISENDV);
MPIU_Assert(n_iov <= MPID_IOV_LIMIT);
MPIU_Assert(iov[0].MPID_IOV_LEN <= sizeof(MPIDI_CH3_Pkt_t));
/* The sock channel uses a fixed length header, the size of which is the
maximum of all possible packet headers */
iov[0].MPID_IOV_LEN = sizeof(MPIDI_CH3_Pkt_t);
MPIU_DBG_STMT(CH3_CHANNEL,VERBOSE,
MPIDI_DBG_Print_packet((MPIDI_CH3_Pkt_t *)iov[0].MPID_IOV_BUF));
if (vcch->state == MPIDI_CH3I_VC_STATE_CONNECTED) /* MT */
{
/* Connection already formed. If send queue is empty attempt to send
data, queuing any unsent data. */
if (MPIDI_CH3I_SendQ_empty(vcch)) /* MT */
{
MPIU_Size_t nb;
int rc;
MPIU_DBG_MSG(CH3_CHANNEL,VERBOSE,
"send queue empty, attempting to write");
MPIU_DBG_PKT(vcch->conn,(MPIDI_CH3_Pkt_t*)iov[0].MPID_IOV_BUF,
"isendv");
/* MT - need some signalling to lock down our right to use the
channel, thus insuring that the progress engine does
also try to write */
/* FIXME: the current code only agressively writes the first IOV.
Eventually it should be changed to agressively write
as much as possible. Ideally, the code would be shared between
the send routines and the progress engine. */
rc = MPIDU_Sock_writev(vcch->sock, iov, n_iov, &nb);
if (rc == MPI_SUCCESS)
{
int offset = 0;
MPIU_DBG_MSG_D(CH3_CHANNEL,VERBOSE,
"wrote %ld bytes", (unsigned long) nb);
while (offset < n_iov)
{
if ((int)iov[offset].MPID_IOV_LEN <= nb)
{
nb -= iov[offset].MPID_IOV_LEN;
offset++;
}
else
{
MPIU_DBG_MSG(CH3_CHANNEL,VERBOSE,
"partial write, request enqueued at head");
update_request(sreq, iov, n_iov, offset, nb);
MPIDI_CH3I_SendQ_enqueue_head(vcch, sreq);
MPIU_DBG_MSG_FMT(CH3_CHANNEL,VERBOSE,
(MPIU_DBG_FDEST,"posting writev, vc=0x%p, sreq=0x%08x", vc, sreq->handle));
vcch->conn->send_active = sreq;
mpi_errno = MPIDU_Sock_post_writev(vcch->conn->sock,
sreq->dev.iov + offset,
sreq->dev.iov_count - offset, NULL);
/* --BEGIN ERROR HANDLING-- */
if (mpi_errno != MPI_SUCCESS)
{
mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER,
"**ch3|sock|postwrite", "ch3|sock|postwrite %p %p %p",
sreq, vcch->conn, vc);
}
/* --END ERROR HANDLING-- */
break;
}
}
if (offset == n_iov)
{
MPIU_DBG_MSG(CH3_CHANNEL,VERBOSE,
"write complete, calling OnDataAvail fcn");
reqFn = sreq->dev.OnDataAvail;
if (!reqFn) {
MPIU_Assert(MPIDI_Request_get_type(sreq)!=MPIDI_REQUEST_TYPE_GET_RESP);
MPIDI_CH3U_Request_complete(sreq);
}
else {
int complete;
mpi_errno = reqFn( vc, sreq, &complete );
if (mpi_errno) MPIU_ERR_POP(mpi_errno);
if (!complete) {
MPIDI_CH3I_SendQ_enqueue_head(vcch, sreq);
MPIU_DBG_MSG_FMT(CH3_CHANNEL,VERBOSE,
(MPIU_DBG_FDEST,"posting writev, vc=0x%p, sreq=0x%08x", vc, sreq->handle));
vcch->conn->send_active = sreq;
mpi_errno = MPIDU_Sock_post_writev(
vcch->conn->sock, sreq->dev.iov,
sreq->dev.iov_count, NULL);
/* --BEGIN ERROR HANDLING-- */
if (mpi_errno != MPI_SUCCESS)
{
mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL, FCNAME, __LINE__, MPI_ERR_OTHER,
"**ch3|sock|postwrite", "ch3|sock|postwrite %p %p %p",
sreq, vcch->conn, vc);
}
/* --END ERROR HANDLING-- */
}
}
}
}
/* --BEGIN ERROR HANDLING-- */
else if (MPIR_ERR_GET_CLASS(rc) == MPIDU_SOCK_ERR_NOMEM)
{
MPIU_DBG_MSG(CH3_CHANNEL,TYPICAL,
"MPIDU_Sock_writev failed, out of memory");
sreq->status.MPI_ERROR = MPIR_ERR_MEMALLOCFAILED;
}
else
{
MPIU_DBG_MSG_D(CH3_CHANNEL,TYPICAL,
"MPIDU_Sock_writev failed, rc=%d", rc);
/* Connection just failed. Mark the request complete and
return an error. */
MPIU_DBG_VCCHSTATECHANGE(vc,VC_STATE_FAILED);
/* FIXME: Shouldn't the vc->state also change? */
vcch->state = MPIDI_CH3I_VC_STATE_FAILED;
sreq->status.MPI_ERROR = MPIR_Err_create_code( rc,
MPIR_ERR_RECOVERABLE, FCNAME, __LINE__,
MPI_ERR_INTERN, "**ch3|sock|writefailed",
"**ch3|sock|writefailed %d", rc );
/* MT - CH3U_Request_complete performs write barrier */
MPIDI_CH3U_Request_complete(sreq);
/* Return error to calling routine */
mpi_errno = sreq->status.MPI_ERROR;
}
/* --END ERROR HANDLING-- */
}
else
{
MPIU_DBG_MSG(CH3_CHANNEL,VERBOSE,"send queue not empty, enqueuing");
update_request(sreq, iov, n_iov, 0, 0);
MPIDI_CH3I_SendQ_enqueue(vcch, sreq);
}
}
else if (vcch->state == MPIDI_CH3I_VC_STATE_CONNECTING)
{
/* queuing the data so it can be sent later. */
MPIU_DBG_VCUSE(vc,"connecting. Enqueuing request");
update_request(sreq, iov, n_iov, 0, 0);
MPIDI_CH3I_SendQ_enqueue(vcch, sreq);
}
else if (vcch->state == MPIDI_CH3I_VC_STATE_UNCONNECTED)
{
/* Form a new connection, queuing the data so it can be sent later. */
MPIU_DBG_VCUSE(vc,"unconnected. Enqueuing request");
update_request(sreq, iov, n_iov, 0, 0);
MPIDI_CH3I_SendQ_enqueue(vcch, sreq);
mpi_errno = MPIDI_CH3I_VC_post_connect(vc);
if (mpi_errno) {
MPIU_ERR_POP(mpi_errno);
}
}
else if (vcch->state != MPIDI_CH3I_VC_STATE_FAILED)
{
/* Unable to send data at the moment, so queue it for later */
MPIU_DBG_VCUSE(vc,"still connecting. enqueuing request");
update_request(sreq, iov, n_iov, 0, 0);
MPIDI_CH3I_SendQ_enqueue(vcch, sreq);
}
/* --BEGIN ERROR HANDLING-- */
else
{
MPIU_DBG_VCUSE(vc,"connection failed");
/* Connection failed. Mark the request complete and return an error. */
/* TODO: Create an appropriate error message */
sreq->status.MPI_ERROR = MPI_ERR_INTERN;
/* MT - CH3U_Request_complete performs write barrier */
MPIDI_CH3U_Request_complete(sreq);
}
/* --END ERROR HANDLING-- */
fn_fail:
MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_CH3_ISENDV);
return mpi_errno;
}
