/* 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-- */ } }
/*@ MPI_Request_free - Frees a communication request object Input Parameters: . request - communication request (handle) Notes: This routine is normally used to free inactive persistent requests created with either 'MPI_Recv_init' or 'MPI_Send_init' and friends. It `is` also permissible to free an active request. However, once freed, the request can no longer be used in a wait or test routine (e.g., 'MPI_Wait') to determine completion. This routine may also be used to free a non-persistent requests such as those created with 'MPI_Irecv' or 'MPI_Isend' and friends. Like active persistent requests, once freed, the request can no longer be used with test/wait routines to determine completion. .N ThreadSafe .N Fortran .N Errors .N MPI_SUCCESS .N MPI_ERR_REQUEST .N MPI_ERR_ARG .see also: MPI_Isend, MPI_Irecv, MPI_Issend, MPI_Ibsend, MPI_Irsend, MPI_Recv_init, MPI_Send_init, MPI_Ssend_init, MPI_Rsend_init, MPI_Wait, MPI_Test, MPI_Waitall, MPI_Waitany, MPI_Waitsome, MPI_Testall, MPI_Testany, MPI_Testsome @*/ int MPI_Request_free(MPI_Request * request) { int mpi_errno = MPI_SUCCESS; MPIR_Request *request_ptr = NULL; MPIR_FUNC_TERSE_STATE_DECL(MPID_STATE_MPI_REQUEST_FREE); MPIR_ERRTEST_INITIALIZED_ORDIE(); MPID_THREAD_CS_ENTER(GLOBAL, MPIR_THREAD_GLOBAL_ALLFUNC_MUTEX); MPIR_FUNC_TERSE_ENTER(MPID_STATE_MPI_REQUEST_FREE); /* Validate handle parameters needing to be converted */ #ifdef HAVE_ERROR_CHECKING { MPID_BEGIN_ERROR_CHECKS; { MPIR_ERRTEST_ARGNULL(request, "request", mpi_errno); MPIR_ERRTEST_REQUEST(*request, mpi_errno); } MPID_END_ERROR_CHECKS; } #endif /* HAVE_ERROR_CHECKING */ /* Convert MPI object handles to object pointers */ MPIR_Request_get_ptr(*request, request_ptr); /* Validate object pointers if error checking is enabled */ #ifdef HAVE_ERROR_CHECKING { MPID_BEGIN_ERROR_CHECKS; { /* Validate request_ptr */ MPIR_Request_valid_ptr(request_ptr, mpi_errno); if (mpi_errno) goto fn_fail; } MPID_END_ERROR_CHECKS; } #endif /* HAVE_ERROR_CHECKING */ /* ... body of routine ... */ MPID_Progress_poke(); switch (request_ptr->kind) { case MPIR_REQUEST_KIND__SEND: { MPII_SENDQ_FORGET(request_ptr); break; } case MPIR_REQUEST_KIND__RECV: { break; } case MPIR_REQUEST_KIND__PREQUEST_SEND: { /* If this is an active persistent request, we must also * release the partner request. */ if (request_ptr->u.persist.real_request != NULL) { if (request_ptr->u.persist.real_request->kind == MPIR_REQUEST_KIND__GREQUEST) { /* This is needed for persistent Bsend requests */ mpi_errno = MPIR_Grequest_free(request_ptr->u.persist.real_request); } MPIR_Request_free(request_ptr->u.persist.real_request); } break; } case MPIR_REQUEST_KIND__PREQUEST_RECV: { /* If this is an active persistent request, we must also * release the partner request. */ if (request_ptr->u.persist.real_request != NULL) { MPIR_Request_free(request_ptr->u.persist.real_request); } break; } case MPIR_REQUEST_KIND__GREQUEST: { mpi_errno = MPIR_Grequest_free(request_ptr); break; } /* --BEGIN ERROR HANDLING-- */ default: { mpi_errno = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**request_invalid_kind", "**request_invalid_kind %d", request_ptr->kind); break; } /* --END ERROR HANDLING-- */ } MPIR_Request_free(request_ptr); *request = MPI_REQUEST_NULL; if (mpi_errno != MPI_SUCCESS) goto fn_fail; /* ... end of body of routine ... */ fn_exit: MPIR_FUNC_TERSE_EXIT(MPID_STATE_MPI_REQUEST_FREE); MPID_THREAD_CS_EXIT(GLOBAL, MPIR_THREAD_GLOBAL_ALLFUNC_MUTEX); return mpi_errno; fn_fail: /* --BEGIN ERROR HANDLING-- */ #ifdef HAVE_ERROR_CHECKING { mpi_errno = MPIR_Err_create_code(mpi_errno, MPIR_ERR_RECOVERABLE, FCNAME, __LINE__, MPI_ERR_OTHER, "**mpi_request_free", "**mpi_request_free %p", request); } #endif mpi_errno = MPIR_Err_return_comm(0, FCNAME, mpi_errno); goto fn_exit; /* --END ERROR HANDLING-- */ }