static void _mxm_recv_completion_cb(void *context)
{
MPID_Request *req = (MPID_Request *) context;
mxm_recv_req_t *mxm_rreq;
MPID_nem_mxm_req_area *req_area = NULL;
MPIU_Assert(req);
_dbg_mxm_out_req(req);
req_area = REQ_BASE(req);
_mxm_to_mpi_status(req_area->mxm_req->item.base.error, &req->status);
mxm_rreq = &req_area->mxm_req->item.recv;
req->status.MPI_TAG = _mxm_tag_mxm2mpi(mxm_rreq->completion.sender_tag);
req->status.MPI_SOURCE = mxm_rreq->completion.sender_imm;
req->dev.recv_data_sz = mxm_rreq->completion.actual_len;
MPIR_STATUS_SET_COUNT(req->status, req->dev.recv_data_sz);
if (req->ch.vc) {
MPID_nem_mxm_vc_area *vc_area = VC_BASE(req->ch.vc);
list_enqueue(&vc_area->mxm_ep->free_queue, &req_area->mxm_req->queue);
}
else {
list_enqueue(&mxm_obj->free_queue, &req_area->mxm_req->queue);
}
_dbg_mxm_output(5, "========> %s RECV req %p status %d\n",
(MPIR_STATUS_GET_CANCEL_BIT(req->status) ? "Canceling" : "Completing"),
req, req->status.MPI_ERROR);
if (likely(!MPIR_STATUS_GET_CANCEL_BIT(req->status))) {
_mxm_handle_rreq(req);
}
}
PMPI_LOCAL int MPIR_Ibsend_cancel( void *extra, int complete )
{
int mpi_errno = MPI_SUCCESS;
ibsend_req_info *ibsend_info = (ibsend_req_info *)extra;
MPI_Status status;
MPIR_Request *req = ibsend_info->req;
MPI_Request req_hdl = req->handle;
/* FIXME: There should be no unreferenced args! */
/* Note that this value should always be 1 because
Grequest_complete is called on this request when it is
created */
MPL_UNREFERENCED_ARG(complete);
/* Try to cancel the underlying request */
mpi_errno = MPIR_Cancel_impl(req);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
mpi_errno = MPIR_Wait_impl( &req_hdl, &status );
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
ibsend_info->cancelled = MPIR_STATUS_GET_CANCEL_BIT(status);
/* If the cancelation is successful, free the memory in the
attached buffer used by the request */
if (ibsend_info->cancelled) {
mpi_errno = MPIR_Bsend_free_req_seg(ibsend_info->req);
if (mpi_errno) MPIR_ERR_POP(mpi_errno);
}
fn_exit:
return mpi_errno;
fn_fail:
goto fn_exit;
}
static void _mxm_send_completion_cb(void *context)
{
MPID_Request *req = (MPID_Request *) context;
MPID_nem_mxm_vc_area *vc_area = NULL;
MPID_nem_mxm_req_area *req_area = NULL;
MPIU_Assert(req);
_dbg_mxm_out_req(req);
vc_area = VC_BASE(req->ch.vc);
req_area = REQ_BASE(req);
_mxm_to_mpi_status(req_area->mxm_req->item.base.error, &req->status);
list_enqueue(&vc_area->mxm_ep->free_queue, &req_area->mxm_req->queue);
_dbg_mxm_output(5, "========> %s SEND req %p status %d\n",
(MPIR_STATUS_GET_CANCEL_BIT(req->status) ? "Canceling" : "Completing"),
req, req->status.MPI_ERROR);
if (likely(!MPIR_STATUS_GET_CANCEL_BIT(req->status))) {
_mxm_handle_sreq(req);
}
}
/* Complete a request, saving the status data if necessary.
"active" has meaning only if the request is a persistent request; this
allows the completion routines to indicate that a persistent request
was inactive and did not require any extra completion operation.
If debugger information is being provided for pending (user-initiated)
send operations, the macros MPIR_SENDQ_FORGET will be defined to
call the routine MPIR_Sendq_forget; otherwise that macro will be a no-op.
The implementation of the MPIR_Sendq_xxx is in src/mpi/debugger/dbginit.c .
*/
int MPIR_Request_complete(MPI_Request * request, MPID_Request * request_ptr,
MPI_Status * status, int * active)
{
int mpi_errno = MPI_SUCCESS;
*active = TRUE;
switch(request_ptr->kind)
{
case MPID_REQUEST_SEND:
{
if (status != MPI_STATUS_IGNORE)
{
MPIR_STATUS_SET_CANCEL_BIT(*status, MPIR_STATUS_GET_CANCEL_BIT(request_ptr->status));
}
mpi_errno = request_ptr->status.MPI_ERROR;
MPIR_SENDQ_FORGET(request_ptr);
MPID_Request_release(request_ptr);
if (NULL != request) *request = MPI_REQUEST_NULL;
break;
}
case MPID_REQUEST_RECV:
{
MPIR_Request_extract_status(request_ptr, status);
mpi_errno = request_ptr->status.MPI_ERROR;
MPID_Request_release(request_ptr);
if (NULL != request) *request = MPI_REQUEST_NULL;
break;
}
case MPID_PREQUEST_SEND:
{
if (request_ptr->partner_request != NULL)
{
MPID_Request * prequest_ptr = request_ptr->partner_request;
/* reset persistent request to inactive state */
MPID_cc_set(&request_ptr->cc, 0);
request_ptr->cc_ptr = &request_ptr->cc;
request_ptr->partner_request = NULL;
if (prequest_ptr->kind != MPID_UREQUEST)
{
if (status != MPI_STATUS_IGNORE)
{
MPIR_STATUS_SET_CANCEL_BIT(*status, MPIR_STATUS_GET_CANCEL_BIT(prequest_ptr->status));
}
mpi_errno = prequest_ptr->status.MPI_ERROR;
}
else
{
/* This is needed for persistent Bsend requests */
int rc;
rc = MPIR_Grequest_query(prequest_ptr);
if (mpi_errno == MPI_SUCCESS)
{
mpi_errno = rc;
}
if (status != MPI_STATUS_IGNORE)
{
MPIR_STATUS_SET_CANCEL_BIT(*status, MPIR_STATUS_GET_CANCEL_BIT(prequest_ptr->status));
}
if (mpi_errno == MPI_SUCCESS)
{
mpi_errno = prequest_ptr->status.MPI_ERROR;
}
rc = MPIR_Grequest_free(prequest_ptr);
if (mpi_errno == MPI_SUCCESS)
{
mpi_errno = rc;
}
}
MPID_Request_release(prequest_ptr);
}
else
{
if (request_ptr->status.MPI_ERROR != MPI_SUCCESS)
{
/* if the persistent request failed to start then make the
error code available */
if (status != MPI_STATUS_IGNORE)
{
MPIR_STATUS_SET_CANCEL_BIT(*status, FALSE);
}
mpi_errno = request_ptr->status.MPI_ERROR;
}
else
{
MPIR_Status_set_empty(status);
*active = FALSE;
}
}
break;
}
case MPID_PREQUEST_RECV:
{
if (request_ptr->partner_request != NULL)
{
MPID_Request * prequest_ptr = request_ptr->partner_request;
/* reset persistent request to inactive state */
MPID_cc_set(&request_ptr->cc, 0);
request_ptr->cc_ptr = &request_ptr->cc;
request_ptr->partner_request = NULL;
MPIR_Request_extract_status(prequest_ptr, status);
mpi_errno = prequest_ptr->status.MPI_ERROR;
MPID_Request_release(prequest_ptr);
}
else
{
MPIR_Status_set_empty(status);
/* --BEGIN ERROR HANDLING-- */
if (request_ptr->status.MPI_ERROR != MPI_SUCCESS)
{
/* if the persistent request failed to start then make the
error code available */
mpi_errno = request_ptr->status.MPI_ERROR;
}
else
{
*active = FALSE;
}
/* --END ERROR HANDLING-- */
}
break;
}
case MPID_UREQUEST:
{
int rc;
rc = MPIR_Grequest_query(request_ptr);
if (mpi_errno == MPI_SUCCESS)
{
mpi_errno = rc;
}
MPIR_Request_extract_status(request_ptr, status);
rc = MPIR_Grequest_free(request_ptr);
if (mpi_errno == MPI_SUCCESS)
{
mpi_errno = rc;
}
MPID_Request_release(request_ptr);
if (NULL != request) *request = MPI_REQUEST_NULL;
break;
}
case MPID_COLL_REQUEST:
case MPID_WIN_REQUEST:
{
mpi_errno = request_ptr->status.MPI_ERROR;
MPIR_Request_extract_status(request_ptr, status);
MPID_Request_release(request_ptr);
if (NULL != request) *request = MPI_REQUEST_NULL;
break;
}
default:
{
/* --BEGIN ERROR HANDLING-- */
/* This should not happen */
MPIR_ERR_SETANDSTMT1(mpi_errno, MPI_ERR_INTERN,;, "**badcase",
"**badcase %d", request_ptr->kind);
break;
/* --END ERROR HANDLING-- */
}
}
