mpid_nem_lmt.c

fortran并行计算包

       rts_sreq, then MPID_Cancel_send() is responsible for releasing
       the RTS request object. */
    MPIDI_Request_fetch_and_clear_rts_sreq(sreq, &rts_sreq);
    if (rts_sreq != NULL)
        MPID_Request_release(rts_sreq);

    if (cts_pkt->cookie_len != 0)
    {
        MPIU_CHKPMEM_MALLOC(sreq->ch.lmt_tmp_cookie.MPID_IOV_BUF, char *, cts_pkt->cookie_len, mpi_errno, "tmp cookie buf");
        sreq->ch.lmt_tmp_cookie.MPID_IOV_LEN = cts_pkt->cookie_len;

        /* if all data has been received, copy it here, otherwise let channel do the copy */
        if (data_len >= cts_pkt->cookie_len)
        {
            MPID_NEM_MEMCPY(sreq->ch.lmt_tmp_cookie.MPID_IOV_BUF, data_buf, cts_pkt->cookie_len);
            mpi_errno = ((MPIDI_CH3I_VC *)vc->channel_private)->lmt_start_send(vc, sreq, sreq->ch.lmt_tmp_cookie);
            if (mpi_errno) MPIU_ERR_POP (mpi_errno);
            *buflen = sizeof(MPIDI_CH3_Pkt_t) + cts_pkt->cookie_len;
            *rreqp = NULL;
        }
        else
        {
            /* create a recv req and set up to receive the cookie into the sreq's tmp_cookie */
            MPID_Request *rreq;
            MPIDI_Request_create_rreq(rreq, mpi_errno, goto fn_fail);
            /* FIXME:  where does this request get freed? */

            rreq->dev.iov[0] = sreq->ch.lmt_tmp_cookie;
            rreq->dev.iov_count = 1;
            rreq->ch.lmt_req = sreq;
            rreq->dev.OnDataAvail = do_send;
            *buflen = sizeof(MPIDI_CH3_Pkt_t);
            *rreqp = rreq;
        }
    }
    else
    {
        MPID_IOV cookie = {0,0};
        mpi_errno = ((MPIDI_CH3I_VC *)vc->channel_private)->lmt_start_send(vc, sreq, cookie);
        if (mpi_errno) MPIU_ERR_POP (mpi_errno);
        *buflen = sizeof(MPIDI_CH3_Pkt_t);
        *rreqp = NULL;
    }

 fn_exit:
    MPIU_CHKPMEM_COMMIT();
    MPIDI_FUNC_EXIT(MPID_STATE_PKT_CTS_HANDLER);
    return mpi_errno;
 fn_fail:
    MPIU_CHKPMEM_REAP();
    goto fn_exit;
}

#undef FUNCNAME
#define FUNCNAME pkt_DONE_handler
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
static int pkt_DONE_handler(MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt, MPIDI_msg_sz_t *buflen, MPID_Request **rreqp)
{
    int mpi_errno = MPI_SUCCESS;
    MPID_nem_pkt_lmt_done_t * const done_pkt = (MPID_nem_pkt_lmt_done_t *)pkt;
    MPID_Request *req;
    MPIDI_STATE_DECL(MPID_STATE_PKT_DONE_HANDLER);

    MPIDI_FUNC_ENTER(MPID_STATE_PKT_DONE_HANDLER);

    *buflen = sizeof(MPIDI_CH3_Pkt_t);
    MPID_Request_get_ptr(done_pkt->req_id, req);

    switch (MPIDI_Request_get_type(req))
    {
    case MPIDI_REQUEST_TYPE_RECV:
        mpi_errno = ((MPIDI_CH3I_VC *)vc->channel_private)->lmt_done_recv(vc, req);
        if (mpi_errno) MPIU_ERR_POP(mpi_errno);
        break;
    case MPIDI_REQUEST_TYPE_SEND:
        mpi_errno = ((MPIDI_CH3I_VC *)vc->channel_private)->lmt_done_send(vc, req);
        if (mpi_errno) MPIU_ERR_POP(mpi_errno);
        break;
    default:
        MPIU_ERR_SETANDJUMP1(mpi_errno, MPI_ERR_OTHER, "**intern", "**intern %s", "unexpected request type");
        break;
    }

    *rreqp = NULL;

 fn_exit:
    MPIDI_FUNC_EXIT(MPID_STATE_PKT_DONE_HANDLER);
    return mpi_errno;
 fn_fail:
    goto fn_exit;
}

#undef FUNCNAME
#define FUNCNAME pkt_COOKIE_handler
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
static int pkt_COOKIE_handler(MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt, MPIDI_msg_sz_t *buflen, MPID_Request **rreqp)
{
    int mpi_errno = MPI_SUCCESS;
    MPID_nem_pkt_lmt_cookie_t * const cookie_pkt = (MPID_nem_pkt_lmt_cookie_t *)pkt;
    MPID_Request *req;
    char *data_buf;
    MPIDI_msg_sz_t data_len;
    MPIU_CHKPMEM_DECL(1);
    MPIDI_STATE_DECL(MPID_STATE_PKT_COOKIE_HANDLER);

    MPIDI_FUNC_ENTER(MPID_STATE_PKT_COOKIE_HANDLER);

    data_len = *buflen - sizeof(MPIDI_CH3_Pkt_t);
    data_buf = (char *)pkt + sizeof(MPIDI_CH3_Pkt_t);

    MPID_Request_get_ptr(cookie_pkt->req_id, req);

    if (cookie_pkt->cookie_len != 0)
    {
        if (data_len >= cookie_pkt->cookie_len)
        {
            /* call handle cookie with cookie data in receive buffer */
            MPID_IOV cookie;

            cookie.MPID_IOV_BUF = data_buf;
            cookie.MPID_IOV_LEN = cookie_pkt->cookie_len;
            mpi_errno = ((MPIDI_CH3I_VC *)vc->channel_private)->lmt_handle_cookie(vc, req, cookie);
            if (mpi_errno) MPIU_ERR_POP(mpi_errno);

            *rreqp = NULL;
            *buflen = sizeof(MPIDI_CH3_Pkt_t) + cookie_pkt->cookie_len;
        }
        else
        {
            /* create a recv req and set up to receive the cookie into the rreq's tmp_cookie */
            MPID_Request *rreq;

            MPIDI_Request_create_rreq(rreq, mpi_errno, goto fn_fail);
            MPIU_CHKPMEM_MALLOC(rreq->ch.lmt_tmp_cookie.MPID_IOV_BUF, char *, cookie_pkt->cookie_len, mpi_errno, "tmp cookie buf");
            /* FIXME:  where does this request get freed? */
            rreq->ch.lmt_tmp_cookie.MPID_IOV_LEN = cookie_pkt->cookie_len;

            rreq->dev.iov[0] = rreq->ch.lmt_tmp_cookie;
            rreq->dev.iov_count = 1;
            rreq->ch.lmt_req = req;
            rreq->dev.OnDataAvail = do_cookie;
            *rreqp = rreq;
            *buflen = sizeof(MPIDI_CH3_Pkt_t);
        }
    }
    else
    {
        MPID_IOV cookie = {0,0};

        mpi_errno = ((MPIDI_CH3I_VC *)vc->channel_private)->lmt_handle_cookie(vc, req, cookie);
        if (mpi_errno) MPIU_ERR_POP(mpi_errno);
        *buflen = sizeof(MPIDI_CH3_Pkt_t);
        *rreqp = NULL;
    }

 fn_exit:
    MPIU_CHKPMEM_COMMIT();
    MPIDI_FUNC_EXIT(MPID_STATE_PKT_COOKIE_HANDLER);
    return mpi_errno;
 fn_fail:
    MPIU_CHKPMEM_REAP();
    goto fn_exit;
}


#undef FUNCNAME
#define FUNCNAME do_cts
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
static int do_cts(MPIDI_VC_t *vc, MPID_Request *rreq, int *complete)
{
    int mpi_errno = MPI_SUCCESS;
    MPIDI_msg_sz_t data_sz;
    int dt_contig;
    MPI_Aint dt_true_lb;
    MPID_Datatype * dt_ptr;
    MPID_IOV s_cookie;
    MPIDI_STATE_DECL(MPID_STATE_DO_CTS);

    MPIDI_FUNC_ENTER(MPID_STATE_DO_CTS);

    MPIU_DBG_MSG(CH3_OTHER,VERBOSE,"posted request found");

    /* determine amount of data to be transfered and check for truncation */
    MPIDI_Datatype_get_info(rreq->dev.user_count, rreq->dev.datatype, dt_contig, data_sz, dt_ptr, dt_true_lb);
    if (rreq->ch.lmt_data_sz > data_sz)
    {
        MPIU_ERR_SET2(rreq->status.MPI_ERROR, MPI_ERR_TRUNCATE, "**truncate", "**truncate %d %d", rreq->ch.lmt_data_sz, data_sz);
        rreq->ch.lmt_data_sz = data_sz;
    }

    s_cookie = rreq->ch.lmt_tmp_cookie;

    mpi_errno = ((MPIDI_CH3I_VC *)vc->channel_private)->lmt_start_recv(vc, rreq, s_cookie);
    if (mpi_errno) MPIU_ERR_POP(mpi_errno);

    /* free cookie buffer allocated in RTS handler */
    if (rreq->ch.lmt_tmp_cookie.MPID_IOV_LEN)
    {
        MPIU_Free(rreq->ch.lmt_tmp_cookie.MPID_IOV_BUF);
        rreq->ch.lmt_tmp_cookie.MPID_IOV_LEN = 0;
    }

    *complete = TRUE;

 fn_exit:
    MPIDI_FUNC_EXIT(MPID_STATE_DO_CTS);
    return mpi_errno;
 fn_fail:
    goto fn_exit;
}

#undef FUNCNAME
#define FUNCNAME do_send
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
static int do_send(MPIDI_VC_t *vc, MPID_Request *rreq, int *complete)
{
    int mpi_errno = MPI_SUCCESS;
    MPID_IOV r_cookie;
    MPID_Request * const sreq = rreq->ch.lmt_req;
    MPIDI_STATE_DECL(MPID_STATE_DO_SEND);

    MPIDI_FUNC_ENTER(MPID_STATE_DO_SEND);

    r_cookie = sreq->ch.lmt_tmp_cookie;

    mpi_errno = ((MPIDI_CH3I_VC *)vc->channel_private)->lmt_start_send(vc, sreq, r_cookie);
    if (mpi_errno) MPIU_ERR_POP(mpi_errno);

    /* free cookie buffer allocated in CTS handler */
    MPIU_Free(sreq->ch.lmt_tmp_cookie.MPID_IOV_BUF);
    sreq->ch.lmt_tmp_cookie.MPID_IOV_LEN = 0;

    *complete = TRUE;

 fn_exit:
    MPIDI_FUNC_EXIT(MPID_STATE_DO_SEND);
    return mpi_errno;
 fn_fail:
    goto fn_exit;
}

#undef FUNCNAME
#define FUNCNAME do_cookie
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
static int do_cookie(MPIDI_VC_t *vc, MPID_Request *rreq, int *complete)
{
    int mpi_errno = MPI_SUCCESS;
    MPID_IOV cookie;
    MPID_Request *req = rreq->ch.lmt_req;
    MPIDI_STATE_DECL(MPID_STATE_DO_COOKIE);

    MPIDI_FUNC_ENTER(MPID_STATE_DO_COOKIE);

    cookie = req->ch.lmt_tmp_cookie;

    mpi_errno = ((MPIDI_CH3I_VC *)vc->channel_private)->lmt_handle_cookie(vc, req, cookie);
    if (mpi_errno) MPIU_ERR_POP (mpi_errno);

    /* free cookie buffer allocated in COOKIE handler */
    MPIU_Free(req->ch.lmt_tmp_cookie.MPID_IOV_BUF);
    req->ch.lmt_tmp_cookie.MPID_IOV_LEN = 0;

    *complete = TRUE;

 fn_exit:
    MPIDI_FUNC_EXIT(MPID_STATE_DO_COOKIE);
    return mpi_errno;
 fn_fail:
    goto fn_exit;
}