int MPIDI_CH3U_Dump_vc_states(void)
{
int mpi_errno = MPI_SUCCESS;
int i;
printf("VC States\n");
for (i = 0; i < MPIDI_Process.my_pg->size; ++i)
printf(" %3d %s\n", i, MPIDI_VC_GetStateString(MPIDI_Process.my_pg->vct[i].state));
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
int MPIDI_VCRT_Release(struct MPIDI_VCRT *vcrt, int isDisconnect )
{
int in_use;
int mpi_errno = MPI_SUCCESS;
MPIDI_STATE_DECL(MPID_STATE_MPIDI_VCRT_RELEASE);
MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_VCRT_RELEASE);
MPIU_Object_release_ref(vcrt, &in_use);
MPIU_DBG_MSG_FMT(REFCOUNT,TYPICAL,(MPIU_DBG_FDEST, "Decr VCRT %p ref count",vcrt));
/* If this VC reference table is no longer in use, we can
decrement the reference count of each of the VCs. If the
count on the VCs goes to zero, then we can decrement the
ref count on the process group and so on.
*/
if (!in_use) {
int i, inuse;
for (i = 0; i < vcrt->size; i++)
{
MPIDI_VC_t * const vc = vcrt->vcr_table[i];
MPIDI_VC_release_ref(vc, &in_use);
/* Dynamic connections start with a refcount of 2 instead of 1.
* That way we can distinguish between an MPI_Free and an
* MPI_Comm_disconnect. */
/* XXX DJG FIXME-MT should we be checking this? */
/* probably not, need to do something like the following instead: */
#if 0
if (isDisconnect) {
MPIU_Assert(in_use);
/* FIXME this is still bogus, the VCRT may contain a mix of
* dynamic and non-dynamic VCs, so the ref_count isn't
* guaranteed to have started at 2. The best thing to do might
* be to avoid overloading the reference counting this way and
* use a separate check for dynamic VCs (another flag? compare
* PGs?) */
MPIU_Object_release_ref(vc, &in_use);
}
#endif
if (isDisconnect && MPIU_Object_get_ref(vc) == 1) {
MPIDI_VC_release_ref(vc, &in_use);
}
if (!in_use)
{
/* If the VC is myself then skip the close message */
if (vc->pg == MPIDI_Process.my_pg &&
vc->pg_rank == MPIDI_Process.my_pg_rank)
{
MPIDI_PG_release_ref(vc->pg, &inuse);
if (inuse == 0)
{
MPIDI_PG_Destroy(vc->pg);
}
continue;
}
/* FIXME: the correct test is ACTIVE or REMOTE_CLOSE */
/*if (vc->state != MPIDI_VC_STATE_INACTIVE) { */
if (vc->state == MPIDI_VC_STATE_ACTIVE ||
vc->state == MPIDI_VC_STATE_REMOTE_CLOSE)
{
MPIDI_CH3U_VC_SendClose( vc, i );
}
else
{
MPIDI_PG_release_ref(vc->pg, &inuse);
if (inuse == 0)
{
MPIDI_PG_Destroy(vc->pg);
}
MPIU_DBG_MSG_FMT(CH3_OTHER,VERBOSE,(MPIU_DBG_FDEST,
"vc=%p: not sending a close to %d, vc in state %s",
vc, i, MPIDI_VC_GetStateString(vc->state)));
}
/* NOTE: we used to * MPIDI_CH3_VC_Destroy(&(pg->vct[i])))
here but that is incorrect. According to the standard, it's
entirely possible (likely even) that this VC might still be
connected. VCs are now destroyed when the PG that "owns"
them is destroyed (see MPIDI_PG_Destroy). [goodell@ 2008-06-13] */
}
}
MPIU_Free(vcrt);
}
fn_exit:
MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_VCRT_RELEASE);
return mpi_errno;
fn_fail:
goto fn_exit;
}
int MPIDI_CH3_PktHandler_Close( MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt,
intptr_t *buflen, MPIR_Request **rreqp )
{
MPIDI_CH3_Pkt_close_t * close_pkt = &pkt->close;
int mpi_errno = MPI_SUCCESS;
if (vc->state == MPIDI_VC_STATE_LOCAL_CLOSE)
{
MPIDI_CH3_Pkt_t upkt;
MPIDI_CH3_Pkt_close_t * resp_pkt = &upkt.close;
MPIR_Request * resp_sreq;
MPIDI_Pkt_init(resp_pkt, MPIDI_CH3_PKT_CLOSE);
resp_pkt->ack = TRUE;
MPL_DBG_MSG_D(MPIDI_CH3_DBG_DISCONNECT,TYPICAL,"sending close(TRUE) to %d",
vc->pg_rank);
mpi_errno = MPIDI_CH3_iStartMsg(vc, resp_pkt, sizeof(*resp_pkt), &resp_sreq);
MPIR_ERR_CHKANDJUMP(mpi_errno, mpi_errno, MPI_ERR_OTHER, "**ch3|send_close_ack");
if (resp_sreq != NULL)
{
/* There is still another reference being held by the channel. It
will not be released until the pkt is actually sent. */
MPIR_Request_free(resp_sreq);
}
}
if (close_pkt->ack == FALSE)
{
if (vc->state == MPIDI_VC_STATE_LOCAL_CLOSE)
{
MPL_DBG_MSG_D(MPIDI_CH3_DBG_DISCONNECT,TYPICAL,
"received close(FALSE) from %d, moving to CLOSE_ACKED.",
vc->pg_rank);
MPIDI_CHANGE_VC_STATE(vc, CLOSE_ACKED);
}
else /* (vc->state == MPIDI_VC_STATE_ACTIVE) */
{
if (vc->state != MPIDI_VC_STATE_ACTIVE)
{
MPL_DBG_MSG_FMT(MPIDI_CH3_DBG_DISCONNECT, TYPICAL, (MPL_DBG_FDEST, "Unexpected state %s in vc %p (rank=%d) (expecting MPIDI_VC_STATE_ACTIVE)\n", MPIDI_VC_GetStateString(vc->state), vc, vc->pg_rank ));
MPL_DBG_MSG_D(MPIDI_CH3_DBG_DISCONNECT,TYPICAL,
"received close(FALSE) from %d, moving to REMOTE_CLOSE.",
vc->pg_rank);
}
MPIR_Assert(vc->state == MPIDI_VC_STATE_ACTIVE);
MPIDI_CHANGE_VC_STATE(vc, REMOTE_CLOSE);
}
}
else /* (close_pkt->ack == TRUE) */
{
MPL_DBG_MSG_D(MPIDI_CH3_DBG_DISCONNECT,TYPICAL,
"received close(TRUE) from %d, moving to CLOSED.",
vc->pg_rank);
MPIR_Assert (vc->state == MPIDI_VC_STATE_LOCAL_CLOSE ||
vc->state == MPIDI_VC_STATE_CLOSE_ACKED);
MPIDI_CHANGE_VC_STATE(vc, CLOSED);
/* For example, with sockets, Connection_terminate will close
the socket */
mpi_errno = MPIDI_CH3_Connection_terminate(vc);
}
*buflen = sizeof(MPIDI_CH3_Pkt_t);
*rreqp = NULL;
fn_fail:
return mpi_errno;
}
