int MPIDI_CH3_Rendezvous_unpack_data(MPIDI_VC_t *vc, MPID_Request *rreq)
{
/* If we are using datatype, then need to unpack data from tmpbuf */
int iter = 0;
int copied = 0;
int mpi_errno = MPI_SUCCESS;
int complete;
uintptr_t buf = (uintptr_t) rreq->mrail.rndv_buf;
MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3I_RNDV_UNPACK_DATA);
MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_RNDV_UNPACK_DATA);
for (iter=0; iter < rreq->dev.iov_count; ++iter)
{
MPIU_Memcpy(rreq->dev.iov[iter].MPID_IOV_BUF,
(void *) buf, rreq->dev.iov[iter].MPID_IOV_LEN);
buf += rreq->dev.iov[iter].MPID_IOV_LEN;
copied += rreq->dev.iov[iter].MPID_IOV_LEN;
}
MPIDI_CH3I_Request_adjust_iov(rreq, copied);
while (rreq->dev.OnDataAvail == MPIDI_CH3_ReqHandler_UnpackSRBufReloadIOV
|| rreq->dev.OnDataAvail == MPIDI_CH3_ReqHandler_ReloadIOV)
{
/* XXX: dev.ca should only be CA_COMPLETE? */
/* end of XXX */
mpi_errno = MPIDI_CH3U_Handle_recv_req(vc, rreq, &complete);
/* --BEGIN ERROR HANDLING-- */
if (mpi_errno != MPI_SUCCESS || complete == TRUE)
{
mpi_errno = MPIR_Err_create_code(
mpi_errno,
MPIR_ERR_FATAL,
FCNAME,
__LINE__,
MPI_ERR_OTHER,
"**fail",
0);
goto fn_exit;
}
copied = 0;
for (iter = 0; iter < rreq->dev.iov_count; ++iter)
{
MPIU_Memcpy(rreq->dev.iov[iter].MPID_IOV_BUF,
(void *) buf, rreq->dev.iov[iter].MPID_IOV_LEN);
buf += rreq->dev.iov[iter].MPID_IOV_LEN;
copied += rreq->dev.iov[iter].MPID_IOV_LEN;
}
MPIDI_CH3I_Request_adjust_iov(rreq, copied);
}
fn_exit:
MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_CH3I_RNDV_UNPACK_DATA);
return mpi_errno;
}
int MPIDI_CH3_Rendezvous_rput_finish(MPIDI_VC_t * vc,
MPIDI_CH3_Pkt_rput_finish_t * rf_pkt)
{
int mpi_errno = MPI_SUCCESS;
MPID_Request *rreq;
int complete;
MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3I_RNDV_RPUT_FINISH);
MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_RNDV_RPUT_FINISH);
MPID_Request_get_ptr(rf_pkt->receiver_req_id, rreq);
if (!MPIDI_CH3I_MRAIL_Finish_request(rreq))
{
return MPI_SUCCESS;
}
if (rreq->mrail.rndv_buf_alloc == 1){
MPIDI_CH3_Rendezvous_unpack_data(vc, rreq);
} else {
rreq->mrail.rndv_buf = NULL;
}
#if defined(CKPT)
MPIDI_CH3I_CR_req_dequeue(rreq);
#endif /* defined(CKPT) */
MPIDI_CH3I_MRAILI_RREQ_RNDV_FINISH(rreq);
mpi_errno = MPIDI_CH3U_Handle_recv_req(vc, rreq, &complete);
if (mpi_errno != MPI_SUCCESS)
{
mpi_errno =
MPIR_Err_create_code(mpi_errno,
MPIR_ERR_RECOVERABLE, FCNAME,
__LINE__, MPI_ERR_OTHER, "**fail", 0);
}
if (complete)
{
vc->ch.recv_active = NULL;
}
else
{
mpi_errno =
MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL,
FCNAME, __LINE__,
MPI_ERR_OTHER, "**fail", 0);
goto fn_exit;
}
fn_exit:
MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_CH3I_RNDV_RPUT_FINISH);
return mpi_errno;
}
static int
MPID_nem_newmad_handle_rreq(MPID_Request *req, nm_tag_t match_info, size_t size)
{
int mpi_errno = MPI_SUCCESS;
int complete = FALSE;
int dt_contig;
MPI_Aint dt_true_lb;
MPIDI_msg_sz_t userbuf_sz;
MPID_Datatype *dt_ptr;
MPIDI_msg_sz_t data_sz;
MPIDI_VC_t *vc = NULL;
#ifdef DEBUG
fprintf(stdout,"========> Completing Recv req %p (match is %lx) \n",req,match_info);
#endif
NEM_NMAD_MATCH_GET_RANK(match_info,req->status.MPI_SOURCE);
NEM_NMAD_MATCH_GET_TAG(match_info,req->status.MPI_TAG);
req->status.count = size;
req->dev.recv_data_sz = size;
MPIDI_Datatype_get_info(req->dev.user_count, req->dev.datatype, dt_contig, userbuf_sz, dt_ptr, dt_true_lb);
if (size <= userbuf_sz) {
data_sz = req->dev.recv_data_sz;
}
else
{
MPIU_DBG_MSG_FMT(CH3_OTHER,VERBOSE,(MPIU_DBG_FDEST,
"receive buffer too small; message truncated, msg_sz="
MPIDI_MSG_SZ_FMT ", userbuf_sz="
MPIDI_MSG_SZ_FMT,
req->dev.recv_data_sz, userbuf_sz));
req->status.MPI_ERROR = MPIR_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_TRUNCATE,
"**truncate", "**truncate %d %d %d %d",
req->status.MPI_SOURCE, req->status.MPI_TAG,
req->dev.recv_data_sz, userbuf_sz );
req->status.count = userbuf_sz;
data_sz = userbuf_sz;
}
if ((!dt_contig)&&(req->dev.tmpbuf != NULL))
{
MPIDI_msg_sz_t last;
last = req->dev.recv_data_sz;
MPID_Segment_unpack( req->dev.segment_ptr, 0, &last, req->dev.tmpbuf);
MPIU_Free(req->dev.tmpbuf);
if (last != data_sz) {
req->status.count = (int)last;
if (req->dev.recv_data_sz <= userbuf_sz) {
MPIU_ERR_SETSIMPLE(req->status.MPI_ERROR,MPI_ERR_TYPE,"**dtypemismatch");
}
}
}
if (REQ_FIELD(req,iov) != NULL)
MPIU_Free(REQ_FIELD(req,iov));
MPIDI_Comm_get_vc_set_active(req->comm, req->status.MPI_SOURCE, &vc);
MPIDI_CH3U_Handle_recv_req(vc, req, &complete);
MPIU_Assert(complete == TRUE);
#ifdef DEBUG
fprintf(stdout,"========> Completing Recv req %p done \n",req);
#endif
fn_exit:
return mpi_errno;
fn_fail: ATTRIBUTE((unused))
goto fn_exit;
}
int MPIDI_nem_ib_packetized_recv_data(MPIDI_VC_t * vc, vbuf *v)
{
int mpi_errno = MPI_SUCCESS;
int skipsize = sizeof(MPIDI_CH3_Pkt_packetized_send_data_t);
int nb, complete;
MPID_Request *rreq = VC_FIELD(vc, connection)->packetized_recv;
if (NULL == VC_FIELD(vc, connection)->packetized_recv) {
mpi_errno =
MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL,
FCNAME, __LINE__,
MPI_ERR_OTHER,
"**fail", 0);
goto fn_exit;
}
DEBUG_PRINT("[pkt recv], rreq %p, offset %d, count %d\n", rreq, rreq->dev.iov_offset,
rreq->dev.iov_count);
mpi_errno = MPIDI_nem_ib_fill_request(rreq, v, skipsize, &nb);
if (mpi_errno != MPI_SUCCESS) {
mpi_errno =
MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL,
FCNAME, __LINE__,
MPI_ERR_OTHER, "**fail",
0);
goto fn_exit;
}
skipsize += nb;
if (MPIDI_nem_ib_request_adjust_iov(rreq, nb)) {
mpi_errno = MPIDI_CH3U_Handle_recv_req(vc, rreq, &complete);
DEBUG_PRINT("[recv: handle read] adjust req fine, complete %d\n",
complete);
if (mpi_errno != MPI_SUCCESS) {
mpi_errno =
MPIR_Err_create_code(mpi_errno,
MPIR_ERR_RECOVERABLE, FCNAME,
__LINE__, MPI_ERR_OTHER, "**fail", 0);
goto fn_exit;
}
while (complete != TRUE) {
mpi_errno = MPIDI_nem_ib_fill_request(rreq, v, skipsize, &nb);
if (mpi_errno != MPI_SUCCESS) {
mpi_errno =
MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL,
FCNAME, __LINE__,
MPI_ERR_OTHER, "**fail",
0);
goto fn_exit;
}
if (!MPIDI_nem_ib_request_adjust_iov(rreq, nb)) {
goto fn_exit;
}
skipsize += nb;
mpi_errno = MPIDI_CH3U_Handle_recv_req(vc, rreq, &complete);
DEBUG_PRINT("[recv: handle read] adjust req fine, complete %d\n",
complete);
if (mpi_errno != MPI_SUCCESS) {
mpi_errno =
MPIR_Err_create_code(mpi_errno,
MPIR_ERR_RECOVERABLE, FCNAME,
__LINE__, MPI_ERR_OTHER, "**fail", 0);
goto fn_exit;
}
}
if (TRUE == complete) {
VC_FIELD(vc, connection)->packetized_recv = NULL;
}
}
fn_exit:
return mpi_errno;
}
int MPIDI_CH3_Rendezvous_rget_recv_finish(MPIDI_VC_t * vc,
MPID_Request * rreq)
{
int mpi_errno = MPI_SUCCESS;
int complete;
MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3I_RGET_RECV_FINISH);
MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_RGET_RECV_FINISH);
if (!MPIDI_CH3I_MRAIL_Finish_request(rreq))
{
return MPI_SUCCESS;
}
if (rreq->mrail.rndv_buf_alloc == 1)
{
/* If we are using datatype, then need to unpack data from tmpbuf */
int iter = 0;
int copied = 0;
uintptr_t buf = (uintptr_t) rreq->mrail.rndv_buf;
for (; iter < rreq->dev.iov_count; ++iter)
{
MPIU_Memcpy(rreq->dev.iov[iter].MPID_IOV_BUF,
(void *) buf, rreq->dev.iov[iter].MPID_IOV_LEN);
buf += rreq->dev.iov[iter].MPID_IOV_LEN;
copied += rreq->dev.iov[iter].MPID_IOV_LEN;
}
MPIDI_CH3I_Request_adjust_iov(rreq, copied);
while (rreq->dev.OnDataAvail == MPIDI_CH3_ReqHandler_UnpackSRBufReloadIOV
|| rreq->dev.OnDataAvail == MPIDI_CH3_ReqHandler_ReloadIOV)
{
/* XXX: dev.ca should only be CA_COMPLETE? */
/* end of XXX */
mpi_errno = MPIDI_CH3U_Handle_recv_req(vc, rreq, &complete);
if (mpi_errno != MPI_SUCCESS || complete == TRUE)
{
mpi_errno = MPIR_Err_create_code(
mpi_errno,
MPIR_ERR_FATAL,
FCNAME,
__LINE__,
MPI_ERR_OTHER,
"**fail",
0);
goto fn_exit;
}
copied = 0;
for (iter = 0; iter < rreq->dev.iov_count; ++iter)
{
MPIU_Memcpy(rreq->dev.iov[iter].MPID_IOV_BUF,
(void *) buf, rreq->dev.iov[iter].MPID_IOV_LEN);
buf += rreq->dev.iov[iter].MPID_IOV_LEN;
copied += rreq->dev.iov[iter].MPID_IOV_LEN;
}
MPIDI_CH3I_Request_adjust_iov(rreq, copied);
}
}
else
{
rreq->mrail.rndv_buf = NULL;
}
#if defined(CKPT)
MPIDI_CH3I_CR_req_dequeue(rreq);
#endif /* defined(CKPT) */
MPIDI_CH3I_MRAILI_RREQ_RNDV_FINISH(rreq);
mpi_errno = MPIDI_CH3U_Handle_recv_req(vc, rreq, &complete);
if (mpi_errno != MPI_SUCCESS)
{
mpi_errno =
MPIR_Err_create_code(mpi_errno,
MPIR_ERR_RECOVERABLE, FCNAME,
__LINE__, MPI_ERR_OTHER, "**fail", 0);
}
if (complete)
{
vc->ch.recv_active = NULL;
}
else
{
mpi_errno =
MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL,
FCNAME, __LINE__,
MPI_ERR_OTHER, "**fail", 0);
goto fn_exit;
}
fn_exit:
MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_CH3I_RGET_RECV_FINISH);
return mpi_errno;
}
int MPIDI_CH3_Rendezvouz_r3_recv_data(MPIDI_VC_t * vc, vbuf * buffer)
{
int mpi_errno = MPI_SUCCESS;
int skipsize = sizeof(MPIDI_CH3_Pkt_rndv_r3_data_t);
int nb, complete;
MPID_Request *rreq;
MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3I_RNDV_R3_RCV_DATA);
MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_RNDV_R3_RCV_DATA);
MPID_Request_get_ptr(((MPIDI_CH3_Pkt_rndv_r3_data_t *) (buffer->
pheader))->
receiver_req_id, rreq);
if (!(VAPI_PROTOCOL_R3 == rreq->mrail.protocol ||
VAPI_PROTOCOL_RPUT == rreq->mrail.protocol)) {
int rank;
PMI_Get_rank(&rank);
DEBUG_PRINT( "[rank %d]get wrong req protocol, req %p, protocol %d\n", rank,
rreq, rreq->mrail.protocol);
MPIU_Assert(VAPI_PROTOCOL_R3 == rreq->mrail.protocol ||
VAPI_PROTOCOL_RPUT == rreq->mrail.protocol);
}
rreq->mrail.protocol = VAPI_PROTOCOL_R3;
mpi_errno = MPIDI_CH3I_MRAIL_Fill_Request(rreq, buffer, skipsize, &nb);
if (mpi_errno != MPI_SUCCESS)
{
mpi_errno = MPIR_Err_create_code(
mpi_errno,
MPIR_ERR_FATAL,
FCNAME,
__LINE__,
MPI_ERR_OTHER,
"**fail",
0);
goto fn_exit;
}
vc->ch.received_r3_data += nb;
skipsize += nb;
DEBUG_PRINT("[recv r3: handle read] filled request nb is %d\n", nb);
if (MPIDI_CH3I_Request_adjust_iov(rreq, nb)) {
mpi_errno = MPIDI_CH3U_Handle_recv_req(vc, rreq, &complete);
DEBUG_PRINT("[recv: handle read] adjust req fine, complete %d\n",
complete);
if (mpi_errno != MPI_SUCCESS) {
mpi_errno =
MPIR_Err_create_code(mpi_errno,
MPIR_ERR_RECOVERABLE, FCNAME,
__LINE__, MPI_ERR_OTHER, "**fail", 0);
goto fn_exit;
}
while (complete != TRUE) {
mpi_errno =
MPIDI_CH3I_MRAIL_Fill_Request(rreq, buffer, skipsize, &nb);
if (mpi_errno != MPI_SUCCESS)
{
mpi_errno = MPIR_Err_create_code(
mpi_errno,
MPIR_ERR_FATAL,
FCNAME,
__LINE__,
MPI_ERR_OTHER,
"**fail",
0);
goto fn_exit;
}
vc->ch.received_r3_data += nb;
if (!MPIDI_CH3I_Request_adjust_iov(rreq, nb)) {
goto fn_exit;
}
skipsize += nb;
mpi_errno = MPIDI_CH3U_Handle_recv_req(vc, rreq, &complete);
DEBUG_PRINT
("[recv: handle read] adjust req fine, complete %d\n",
complete);
if (mpi_errno != MPI_SUCCESS) {
mpi_errno =
MPIR_Err_create_code(mpi_errno,
MPIR_ERR_RECOVERABLE, FCNAME,
__LINE__, MPI_ERR_OTHER, "**fail",
0);
goto fn_exit;
}
}
if (TRUE == complete) {
rreq->mrail.protocol = VAPI_PROTOCOL_RENDEZVOUS_UNSPECIFIED;
}
}
fn_exit:
#ifndef DAPL_DEFAULT_PROVIDER
if (MPIDI_CH3I_RDMA_Process.has_srq) {
if ( vc->ch.received_r3_data >= rdma_max_r3_pending_data) {
DEBUG_PRINT("recved data: %d send ack\n", vc->ch.received_r3_data );
MPIDI_CH3I_MRAILI_Rendezvous_r3_ack_send(vc);
}
}
#endif
DEBUG_PRINT("Successfully return from r3 recv\n");
MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_CH3I_RNDV_R3_RCV_DATA);
return mpi_errno;
}
int MPIDI_CH3_Get_rndv_recv(MPIDI_VC_t * vc, MPID_Request * req)
{
int mpi_errno = MPI_SUCCESS;
int complete;
MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3I_RNDV_RECV);
MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_RNDV_RECV);
MPIU_Assert(req->mrail.protocol == VAPI_PROTOCOL_RPUT);
#ifdef CKPT
MPIDI_CH3I_CR_lock();
#endif
if (req->mrail.rndv_buf_alloc == 1)
{
/* If we are using datatype, then need to unpack data from tmpbuf */
int iter = 0;
uintptr_t buf = (uintptr_t) req->mrail.rndv_buf;
for (iter=0; iter < req->dev.iov_count; ++iter)
{
MPIU_Memcpy(req->dev.iov[iter].MPID_IOV_BUF,
(void *) buf, req->dev.iov[iter].MPID_IOV_LEN);
buf += req->dev.iov[iter].MPID_IOV_LEN;
}
while (req->dev.OnDataAvail == MPIDI_CH3_ReqHandler_UnpackSRBufReloadIOV
|| req->dev.OnDataAvail == MPIDI_CH3_ReqHandler_ReloadIOV)
{
/* mpi_errno = MPIDI_CH3U_Request_load_recv_iov(req); */
mpi_errno = MPIDI_CH3U_Handle_recv_req(vc, req, &complete);
if (mpi_errno != MPI_SUCCESS)
{
goto fn_exit;
}
for (iter = 0; iter < req->dev.iov_count; ++iter)
{
MPIU_Memcpy(req->dev.iov[iter].MPID_IOV_BUF,
(void *) buf, req->dev.iov[iter].MPID_IOV_LEN);
buf += req->dev.iov[iter].MPID_IOV_LEN;
}
}
}
else
{
req->mrail.rndv_buf = NULL;
}
MPIDI_CH3I_MRAILI_RREQ_RNDV_FINISH(req);
mpi_errno = MPIDI_CH3U_Handle_recv_req(vc, req, &complete);
if (mpi_errno != MPI_SUCCESS)
{
goto fn_exit;
}
MPIU_Assert(complete == TRUE);
fn_exit:
#if defined(CKPT)
MPIDI_CH3I_CR_unlock();
#endif /* defined(CKPT) */
MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_CH3I_RNDV_RECV);
return mpi_errno;
}
int MPIDI_CH3_Packetized_recv_data(MPIDI_VC_t * vc, vbuf *v)
{
int mpi_errno = MPI_SUCCESS;
int skipsize = sizeof(MPIDI_CH3_Pkt_packetized_send_data_t);
int nb, complete;
MPID_Request *rreq = vc->mrail.packetized_recv;
MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3_PACKETIZED_RECV_DATA);
MPIDI_FUNC_ENTER(MPID_STATE_MPIDI_CH3_PACKETIZED_RECV_DATA);
if (NULL == vc->mrail.packetized_recv) {
mpi_errno =
MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL,
FCNAME, __LINE__,
MPI_ERR_OTHER,
"**fail", 0);
goto fn_exit;
}
DEBUG_PRINT("[pkt recv], rreq %p, offset %d, count %d\n", rreq, rreq->dev.iov_offset,
rreq->dev.iov_count);
mpi_errno = MPIDI_CH3I_MRAIL_Fill_Request(rreq, v, skipsize, &nb);
if (mpi_errno != MPI_SUCCESS) {
mpi_errno =
MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL,
FCNAME, __LINE__,
MPI_ERR_OTHER, "**fail",
0);
goto fn_exit;
}
skipsize += nb;
DEBUG_PRINT("[pkt recv], skipsize %d, filled size %d\n", skipsize, nb);
if (MPIDI_CH3I_Request_adjust_iov(rreq, nb)) {
mpi_errno = MPIDI_CH3U_Handle_recv_req(vc, rreq, &complete);
DEBUG_PRINT("[recv: handle read] adjust req fine, complete %d\n",
complete);
if (mpi_errno != MPI_SUCCESS) {
mpi_errno =
MPIR_Err_create_code(mpi_errno,
MPIR_ERR_RECOVERABLE, FCNAME,
__LINE__, MPI_ERR_OTHER, "**fail", 0);
goto fn_exit;
}
while (complete != TRUE) {
mpi_errno = MPIDI_CH3I_MRAIL_Fill_Request(rreq, v, skipsize, &nb);
if (mpi_errno != MPI_SUCCESS) {
mpi_errno =
MPIR_Err_create_code(mpi_errno, MPIR_ERR_FATAL,
FCNAME, __LINE__,
MPI_ERR_OTHER, "**fail",
0);
goto fn_exit;
}
if (!MPIDI_CH3I_Request_adjust_iov(rreq, nb)) {
goto fn_exit;
}
skipsize += nb;
mpi_errno = MPIDI_CH3U_Handle_recv_req(vc, rreq, &complete);
DEBUG_PRINT("[recv: handle read] adjust req fine, complete %d\n",
complete);
if (mpi_errno != MPI_SUCCESS) {
mpi_errno =
MPIR_Err_create_code(mpi_errno,
MPIR_ERR_RECOVERABLE, FCNAME,
__LINE__, MPI_ERR_OTHER, "**fail", 0);
goto fn_exit;
}
}
if (TRUE == complete) {
vc->mrail.packetized_recv = NULL;
}
}
fn_exit:
MPIDI_FUNC_EXIT(MPID_STATE_MPIDI_CH3_PACKETIZED_RECV_DATA);
return mpi_errno;
}
static int _mxm_handle_rreq(MPID_Request * req)
{
int complete = FALSE, found = FALSE;
int dt_contig;
MPI_Aint dt_true_lb ATTRIBUTE((unused));
MPIDI_msg_sz_t userbuf_sz;
MPID_Datatype *dt_ptr;
MPIDI_msg_sz_t data_sz;
MPID_nem_mxm_vc_area *vc_area ATTRIBUTE((unused)) = NULL;
MPID_nem_mxm_req_area *req_area = NULL;
void *tmp_buf = NULL;
MPID_THREAD_CS_ENTER(POBJ, MPIR_THREAD_MSGQ_MUTEX);
found = MPIDI_CH3U_Recvq_DP(req);
MPID_THREAD_CS_EXIT(POBJ, MPIR_THREAD_MSGQ_MUTEX);
/* an MPI_ANY_SOURCE request may have been previously removed from the
* CH3 queue by an FDP (find and dequeue posted) operation */
if (req->dev.match.parts.rank != MPI_ANY_SOURCE) {
MPIU_Assert(found);
}
MPIDI_Datatype_get_info(req->dev.user_count, req->dev.datatype, dt_contig, userbuf_sz, dt_ptr,
dt_true_lb);
vc_area = VC_BASE(req->ch.vc);
req_area = REQ_BASE(req);
_dbg_mxm_out_buf(req_area->iov_buf[0].ptr,
(req_area->iov_buf[0].length > 16 ? 16 : req_area->iov_buf[0].length));
if (req->dev.recv_data_sz <= userbuf_sz) {
data_sz = req->dev.recv_data_sz;
if (req->status.MPI_ERROR == MPI_ERR_TRUNCATE) {
req->status.MPI_ERROR = MPIR_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, FCNAME, __LINE__,
MPI_ERR_TRUNCATE, "**truncate",
"**truncate %d %d %d %d",
req->status.MPI_SOURCE,
req->status.MPI_TAG, req->dev.recv_data_sz,
userbuf_sz);
}
}
else {
data_sz = userbuf_sz;
MPIR_STATUS_SET_COUNT(req->status, userbuf_sz);
MPIU_DBG_MSG_FMT(CH3_OTHER, VERBOSE, (MPIU_DBG_FDEST,
"receive buffer too small; message truncated, msg_sz="
MPIDI_MSG_SZ_FMT ", userbuf_sz="
MPIDI_MSG_SZ_FMT, req->dev.recv_data_sz, userbuf_sz));
req->status.MPI_ERROR = MPIR_Err_create_code(MPI_SUCCESS,
MPIR_ERR_RECOVERABLE, FCNAME, __LINE__,
MPI_ERR_TRUNCATE, "**truncate",
"**truncate %d %d %d %d",
req->status.MPI_SOURCE, req->status.MPI_TAG,
req->dev.recv_data_sz, userbuf_sz);
}
if (!dt_contig) {
MPIDI_msg_sz_t last = 0;
if (req->dev.tmpbuf != NULL) {
last = req->dev.recv_data_sz;
MPID_Segment_unpack(req->dev.segment_ptr, 0, &last, req->dev.tmpbuf);
tmp_buf = req->dev.tmpbuf;
}
else {
mxm_req_buffer_t *iov_buf;
MPL_IOV *iov;
int n_iov = 0;
int index;
last = req->dev.recv_data_sz;
n_iov = req_area->iov_count;
iov_buf = req_area->iov_buf;
if (last && n_iov > 0) {
iov = MPIU_Malloc(n_iov * sizeof(*iov));
MPIU_Assert(iov);
for (index = 0; index < n_iov; index++) {
iov[index].MPL_IOV_BUF = iov_buf[index].ptr;
iov[index].MPL_IOV_LEN = iov_buf[index].length;
}
MPID_Segment_unpack_vector(req->dev.segment_ptr, req->dev.segment_first, &last, iov,
&n_iov);
MPIU_Free(iov);
}
if (req_area->iov_count > MXM_MPICH_MAX_IOV) {
tmp_buf = req_area->iov_buf;
req_area->iov_buf = req_area->tmp_buf;
req_area->iov_count = 0;
}
}
if (last != data_sz) {
MPIR_STATUS_SET_COUNT(req->status, last);
if (req->dev.recv_data_sz <= userbuf_sz) {
/* If the data can't be unpacked, the we have a
* mismatch between the datatype and the amount of
* data received. Throw away received data.
*/
MPIR_ERR_SETSIMPLE(req->status.MPI_ERROR, MPI_ERR_TYPE, "**dtypemismatch");
}
}
}
MPIDI_CH3U_Handle_recv_req(req->ch.vc, req, &complete);
MPIU_Assert(complete == TRUE);
if (tmp_buf)
MPIU_Free(tmp_buf);
return complete;
}
