2004-10-12 19:50:01 +04:00
|
|
|
/*
|
2005-11-05 22:57:48 +03:00
|
|
|
* Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana
|
|
|
|
* University Research and Technology
|
|
|
|
* Corporation. All rights reserved.
|
|
|
|
* Copyright (c) 2004-2005 The University of Tennessee and The University
|
|
|
|
* of Tennessee Research Foundation. All rights
|
|
|
|
* reserved.
|
2004-11-28 23:09:25 +03:00
|
|
|
* Copyright (c) 2004-2005 High Performance Computing Center Stuttgart,
|
|
|
|
* University of Stuttgart. All rights reserved.
|
2005-03-24 15:43:37 +03:00
|
|
|
* Copyright (c) 2004-2005 The Regents of the University of California.
|
|
|
|
* All rights reserved.
|
2004-11-22 04:38:40 +03:00
|
|
|
* $COPYRIGHT$
|
|
|
|
*
|
|
|
|
* Additional copyrights may follow
|
|
|
|
*
|
2004-10-12 19:50:01 +04:00
|
|
|
* $HEADER$
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "ompi_config.h"
|
2005-08-13 01:42:07 +04:00
|
|
|
#include "ompi/include/constants.h"
|
2004-10-12 19:50:01 +04:00
|
|
|
#include "request/request.h"
|
|
|
|
|
2005-09-13 00:25:01 +04:00
|
|
|
int ompi_request_poll_iterations = 20000;
|
2004-10-12 19:50:01 +04:00
|
|
|
|
2004-10-12 22:01:39 +04:00
|
|
|
int ompi_request_wait_any(
|
2004-10-12 19:50:01 +04:00
|
|
|
size_t count,
|
|
|
|
ompi_request_t ** requests,
|
2005-12-13 11:58:00 +03:00
|
|
|
int *index,
|
2004-10-12 19:50:01 +04:00
|
|
|
ompi_status_public_t * status)
|
|
|
|
{
|
2005-02-16 20:42:07 +03:00
|
|
|
#if OMPI_ENABLE_PROGRESS_THREADS
|
2004-10-12 19:50:01 +04:00
|
|
|
int c;
|
|
|
|
#endif
|
2004-12-06 05:15:34 +03:00
|
|
|
size_t i=0, num_requests_null_inactive=0;
|
2004-10-21 01:41:48 +04:00
|
|
|
int rc = OMPI_SUCCESS;
|
2004-10-20 18:56:52 +04:00
|
|
|
int completed = -1;
|
2004-12-06 05:15:34 +03:00
|
|
|
ompi_request_t **rptr=NULL;
|
|
|
|
ompi_request_t *request=NULL;
|
2004-10-12 19:50:01 +04:00
|
|
|
|
2005-02-16 20:42:07 +03:00
|
|
|
#if OMPI_ENABLE_PROGRESS_THREADS
|
2004-10-12 19:50:01 +04:00
|
|
|
/* poll for completion */
|
2005-07-04 01:38:51 +04:00
|
|
|
opal_atomic_mb();
|
2004-10-12 19:50:01 +04:00
|
|
|
for (c = 0; completed < 0 && c < ompi_request_poll_iterations; c++) {
|
|
|
|
rptr = requests;
|
2004-10-27 02:09:26 +04:00
|
|
|
num_requests_null_inactive = 0;
|
2004-10-21 01:41:48 +04:00
|
|
|
for (i = 0; i < count; i++, rptr++) {
|
2004-10-12 19:50:01 +04:00
|
|
|
request = *rptr;
|
2005-12-13 11:58:00 +03:00
|
|
|
/*
|
|
|
|
* Check for null or completed persistent request.
|
|
|
|
* For MPI_REQUEST_NULL, the req_state is always OMPI_REQUEST_INACTIVE
|
|
|
|
*/
|
2006-01-20 00:46:53 +03:00
|
|
|
if( request->req_state == OMPI_REQUEST_INACTIVE ) {
|
2006-01-20 20:17:13 +03:00
|
|
|
num_requests_null_inactive++;
|
2004-10-12 22:01:39 +04:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (true == request->req_complete) {
|
2004-10-12 19:50:01 +04:00
|
|
|
completed = i;
|
2004-10-12 22:01:39 +04:00
|
|
|
goto finished;
|
2005-12-13 11:58:00 +03:00
|
|
|
}
|
2004-10-12 19:50:01 +04:00
|
|
|
}
|
2006-01-20 20:17:13 +03:00
|
|
|
if( num_requests_null_inactive == count )
|
|
|
|
goto finished;
|
2004-10-12 19:50:01 +04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2004-10-12 22:01:39 +04:00
|
|
|
/* give up and sleep until completion */
|
2005-07-04 02:45:48 +04:00
|
|
|
OPAL_THREAD_LOCK(&ompi_request_lock);
|
2005-03-26 21:49:16 +03:00
|
|
|
ompi_request_waiting++;
|
2006-01-14 01:02:40 +03:00
|
|
|
do {
|
2004-10-12 22:01:39 +04:00
|
|
|
rptr = requests;
|
2004-10-27 02:09:26 +04:00
|
|
|
num_requests_null_inactive = 0;
|
2004-10-21 01:41:48 +04:00
|
|
|
for (i = 0; i < count; i++, rptr++) {
|
2004-10-12 22:01:39 +04:00
|
|
|
request = *rptr;
|
2005-12-13 11:58:00 +03:00
|
|
|
/*
|
|
|
|
* Check for null or completed persistent request.
|
2006-01-20 20:17:13 +03:00
|
|
|
* For MPI_REQUEST_NULL, the req_state is always OMPI_REQUEST_INACTIVE.
|
2005-12-13 11:58:00 +03:00
|
|
|
*/
|
2006-01-20 00:46:53 +03:00
|
|
|
if( request->req_state == OMPI_REQUEST_INACTIVE ) {
|
2004-10-27 02:09:26 +04:00
|
|
|
num_requests_null_inactive++;
|
2004-10-12 22:01:39 +04:00
|
|
|
continue;
|
2004-10-12 19:50:01 +04:00
|
|
|
}
|
2004-10-12 22:01:39 +04:00
|
|
|
if (request->req_complete == true) {
|
|
|
|
completed = i;
|
|
|
|
break;
|
2004-10-12 19:50:01 +04:00
|
|
|
}
|
2004-10-12 22:01:39 +04:00
|
|
|
}
|
2004-10-27 02:09:26 +04:00
|
|
|
if(num_requests_null_inactive == count)
|
2004-10-12 22:01:39 +04:00
|
|
|
break;
|
2006-01-14 01:02:40 +03:00
|
|
|
if (completed < 0) {
|
2005-07-04 02:45:48 +04:00
|
|
|
opal_condition_wait(&ompi_request_cond, &ompi_request_lock);
|
2004-10-12 22:01:39 +04:00
|
|
|
}
|
2006-01-14 01:02:40 +03:00
|
|
|
} while (completed < 0);
|
2004-10-12 22:01:39 +04:00
|
|
|
ompi_request_waiting--;
|
2005-07-04 02:45:48 +04:00
|
|
|
OPAL_THREAD_UNLOCK(&ompi_request_lock);
|
2004-10-12 19:50:01 +04:00
|
|
|
|
2005-02-16 20:42:07 +03:00
|
|
|
#if OMPI_ENABLE_PROGRESS_THREADS
|
2004-10-12 22:01:39 +04:00
|
|
|
finished:
|
2005-02-16 20:42:07 +03:00
|
|
|
#endif /* OMPI_ENABLE_PROGRESS_THREADS */
|
|
|
|
|
2004-10-27 02:09:26 +04:00
|
|
|
if(num_requests_null_inactive == count) {
|
2004-10-12 22:01:39 +04:00
|
|
|
*index = MPI_UNDEFINED;
|
2004-10-27 02:09:26 +04:00
|
|
|
if (MPI_STATUS_IGNORE != status) {
|
|
|
|
*status = ompi_status_empty;
|
|
|
|
}
|
2004-10-12 22:01:39 +04:00
|
|
|
} else {
|
|
|
|
|
|
|
|
/* return status */
|
|
|
|
if (MPI_STATUS_IGNORE != status) {
|
|
|
|
*status = request->req_status;
|
|
|
|
}
|
2005-12-13 11:58:00 +03:00
|
|
|
/* return request to pool */
|
2004-10-20 02:00:19 +04:00
|
|
|
rc = request->req_fini(rptr);
|
2004-10-12 22:01:39 +04:00
|
|
|
*index = completed;
|
|
|
|
}
|
2004-10-12 19:50:01 +04:00
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int ompi_request_wait_all(
|
|
|
|
size_t count,
|
|
|
|
ompi_request_t ** requests,
|
|
|
|
ompi_status_public_t * statuses)
|
|
|
|
{
|
|
|
|
size_t completed = 0, i;
|
|
|
|
ompi_request_t **rptr;
|
|
|
|
ompi_request_t *request;
|
|
|
|
|
|
|
|
rptr = requests;
|
|
|
|
for (i = 0; i < count; i++) {
|
2004-10-14 23:17:16 +04:00
|
|
|
request = *rptr++;
|
2004-10-12 22:01:39 +04:00
|
|
|
if (request->req_complete == true) {
|
2004-10-12 19:50:01 +04:00
|
|
|
completed++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if all requests have not completed -- defer acquiring lock
|
2005-12-13 11:58:00 +03:00
|
|
|
* unless required
|
2004-10-12 19:50:01 +04:00
|
|
|
*/
|
|
|
|
if (completed != count) {
|
2005-11-10 03:45:27 +03:00
|
|
|
|
2004-10-12 19:50:01 +04:00
|
|
|
/*
|
|
|
|
* acquire lock and test for completion - if all requests are
|
|
|
|
* not completed pend on condition variable until a request
|
|
|
|
* completes
|
|
|
|
*/
|
2005-07-04 02:45:48 +04:00
|
|
|
OPAL_THREAD_LOCK(&ompi_request_lock);
|
2004-10-12 19:50:01 +04:00
|
|
|
ompi_request_waiting++;
|
2006-01-20 00:46:53 +03:00
|
|
|
#if OMPI_HAVE_THREAD_SUPPORT
|
|
|
|
/*
|
|
|
|
* confirm the status of the pending requests. We have to do it before
|
|
|
|
* taking the condition or otherwise we can miss some requests completion (the
|
|
|
|
* one that happpens between our initial test and the aquisition of the lock).
|
|
|
|
*/
|
|
|
|
rptr = requests;
|
|
|
|
for( completed = i = 0; i < count; i++ ) {
|
|
|
|
request = *rptr++;
|
|
|
|
if (request->req_complete == true) {
|
|
|
|
completed++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* OMPI_HAVE_THREAD_SUPPORT */
|
2006-01-20 20:17:13 +03:00
|
|
|
while( completed != count ) {
|
2005-11-10 03:45:27 +03:00
|
|
|
/* check number of pending requests */
|
|
|
|
size_t start = ompi_request_completed;
|
|
|
|
size_t pending = count - completed;
|
|
|
|
/*
|
|
|
|
* wait until at least pending requests complete
|
2006-01-20 20:17:13 +03:00
|
|
|
*/
|
2005-11-10 03:45:27 +03:00
|
|
|
while (pending > ompi_request_completed - start) {
|
|
|
|
opal_condition_wait(&ompi_request_cond, &ompi_request_lock);
|
|
|
|
}
|
|
|
|
/*
|
2006-01-20 00:46:53 +03:00
|
|
|
* confirm that all pending operations have completed.
|
|
|
|
*/
|
2004-10-12 19:50:01 +04:00
|
|
|
rptr = requests;
|
2006-01-20 00:46:53 +03:00
|
|
|
for( completed = i = 0; i < count; i++ ) {
|
2004-10-14 23:17:16 +04:00
|
|
|
request = *rptr++;
|
2004-10-14 02:56:42 +04:00
|
|
|
if (request->req_complete == true) {
|
2004-10-12 19:50:01 +04:00
|
|
|
completed++;
|
|
|
|
}
|
|
|
|
}
|
2006-01-20 20:17:13 +03:00
|
|
|
}
|
2004-10-12 19:50:01 +04:00
|
|
|
ompi_request_waiting--;
|
2005-07-04 02:45:48 +04:00
|
|
|
OPAL_THREAD_UNLOCK(&ompi_request_lock);
|
2004-10-12 19:50:01 +04:00
|
|
|
}
|
|
|
|
|
2004-10-27 02:09:26 +04:00
|
|
|
if (MPI_STATUSES_IGNORE != statuses) {
|
2004-10-12 19:50:01 +04:00
|
|
|
/* fill out status and free request if required */
|
|
|
|
rptr = requests;
|
|
|
|
for (i = 0; i < count; i++) {
|
2004-10-12 22:01:39 +04:00
|
|
|
int rc;
|
2004-10-12 19:50:01 +04:00
|
|
|
request = *rptr;
|
2004-10-27 02:09:26 +04:00
|
|
|
if(request == MPI_REQUEST_NULL ||
|
|
|
|
request->req_state == OMPI_REQUEST_INACTIVE) {
|
|
|
|
statuses[i] = ompi_status_empty;
|
|
|
|
} else {
|
|
|
|
statuses[i] = request->req_status;
|
2006-01-20 20:17:13 +03:00
|
|
|
rc = request->req_fini(rptr);
|
|
|
|
if (rc != OMPI_SUCCESS)
|
|
|
|
return rc;
|
2004-10-27 02:09:26 +04:00
|
|
|
}
|
2004-10-12 19:50:01 +04:00
|
|
|
rptr++;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* free request if required */
|
|
|
|
rptr = requests;
|
|
|
|
for (i = 0; i < count; i++) {
|
2004-10-12 22:01:39 +04:00
|
|
|
int rc;
|
2004-10-12 19:50:01 +04:00
|
|
|
request = *rptr;
|
2006-01-20 20:17:13 +03:00
|
|
|
if(request == MPI_REQUEST_NULL ||
|
|
|
|
request->req_state == OMPI_REQUEST_INACTIVE) {
|
|
|
|
rc = request->req_fini(rptr);
|
|
|
|
if (rc != OMPI_SUCCESS)
|
|
|
|
return rc;
|
|
|
|
}
|
2004-10-12 19:50:01 +04:00
|
|
|
rptr++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return OMPI_SUCCESS;
|
|
|
|
}
|
2004-10-12 22:01:39 +04:00
|
|
|
|