[mpich-commits] [mpich] MPICH primary repository branch, master, updated. v3.1.1-43-g283319f
Service Account
noreply at mpich.org
Mon Jun 30 12:34:37 CDT 2014
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "MPICH primary repository".
The branch, master has been updated
via 283319f5d9d1cdbcf016dc0ff8ab284114c0be7e (commit)
via dda458a1234b02a04120c5e06654366cb11396ba (commit)
via 7dbdc413e346dd42121efcbfb7e4fbe2b266dab5 (commit)
via da7700a05be91413a8fb119d0fdf36137dbb739d (commit)
via 73f6a4b3aa9102cd4e06f478e19f9d25df4ff3fc (commit)
via 33b7d251f72bbc82d328f5c8e0c7ede0c0a9c745 (commit)
from 31680ed37675df04df2f234944ff356c0ce80537 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
http://git.mpich.org/mpich.git/commitdiff/283319f5d9d1cdbcf016dc0ff8ab284114c0be7e
commit 283319f5d9d1cdbcf016dc0ff8ab284114c0be7e
Author: Xin Zhao <xinzhao3 at illinois.edu>
Date: Mon Jun 30 09:51:59 2014 -0500
Add CVAR (# of tested reqs) to control when to stop in RMA GC function
When cleanning up completed requests, the original RMA implementation
keeps traversing the op list until it finds a completed request. This
may cause significant O(N) overhead if there is no completed request
in the list. We add a CVAR to let the user control the number of visited
requests as a fixed value.
Note that the default value is set to (-1) in order to be in accordance
with the performance of orignal implementation.
Note that in garbage collection function, if runtime finds a chain
of completed RMA requests, it will temporarily ignore this CVAR
and try to find continuous completed requests as many as possible,
until it meets an incomplete request.
Signed-off-by: Pavan Balaji <balaji at anl.gov>
diff --git a/src/mpid/ch3/src/ch3u_rma_sync.c b/src/mpid/ch3/src/ch3u_rma_sync.c
index d9e8570..216ae1d 100644
--- a/src/mpid/ch3/src/ch3u_rma_sync.c
+++ b/src/mpid/ch3/src/ch3u_rma_sync.c
@@ -62,6 +62,10 @@ cvars:
Threshold for the number of completed requests the runtime finds
before it stops trying to find more completed requests in garbage
collection function.
+ Note that it works with MPIR_CVAR_CH3_RMA_GC_NUM_TESTED as an OR
+ relation, which means runtime will stop checking when either one
+ of its following conditions is satisfied or one of conditions of
+ MPIR_CVAR_CH3_RMA_GC_NUM_TESTED is satisfied.
When it is set to negative value, it means runtime will not stop
checking the operation list until it reaches the end of the list.
When it is set to positive value, it means runtime will not stop
@@ -73,6 +77,36 @@ cvars:
and try to find continuous completed requests as many as possible,
until it meets an incomplete request.
+ - name : MPIR_CVAR_CH3_RMA_GC_NUM_TESTED
+ category : CH3
+ type : int
+ default : (-1)
+ class : none
+ verbosity : MPI_T_VERBOSITY_USER_BASIC
+ scope : MPI_T_SCOPE_ALL_EQ
+ description : >-
+ Threshold for the number of RMA requests the runtime tests before
+ it stops trying to check more requests in garbage collection
+ routine.
+ Note that it works with MPIR_CVAR_CH3_RMA_GC_NUM_COMPLETED as an
+ OR relation, which means runtime will stop checking when either
+ one of its following conditions is satisfied or one of conditions
+ of MPIR_CVAR_CH3_RMA_GC_NUM_COMPLETED is satisfied.
+ When it is set to negative value, runtime will not stop checking
+ operation list until runtime reaches the end of the list. It has
+ the risk of O(N) traversing overhead if there is no completed
+ request in the list. When it is set to positive value, it means
+ runtime will not stop checking the operation list until it visits
+ such number of requests. Higher values may make more completed
+ requests to be found, but it has the risk of visiting too many
+ requests, leading to significant performance overhead. When it is
+ set to zero value, runtime will stop checking the operation list
+ immediately, which may cause weird performance in practice.
+ Note that in garbage collection function, if runtime finds a chain
+ of completed RMA requests, it will temporarily ignore this CVAR and
+ try to find continuous completed requests as many as possible, until
+ it meets an incomplete request.
+
- name : MPIR_CVAR_CH3_RMA_LOCK_IMMED
category : CH3
type : boolean
@@ -5609,6 +5643,7 @@ static inline int rma_list_gc( MPID_Win *win_ptr,
int mpi_errno=0;
MPIDI_RMA_Op_t *curr_ptr;
int nComplete = 0;
+ int nVisit = 0;
MPIR_T_PVAR_TIMER_START_VAR(RMA, list_complete_timer);
@@ -5628,11 +5663,17 @@ static inline int rma_list_gc( MPID_Win *win_ptr,
/* --END ERROR HANDLING-- */
MPID_Request_release(curr_ptr->request);
MPIDI_CH3I_RMA_Ops_free_and_next(ops_list, &curr_ptr);
+ nVisit++;
}
while (curr_ptr && curr_ptr != last_elm &&
MPID_Request_is_complete(curr_ptr->request)) ;
- if (MPIR_CVAR_CH3_RMA_GC_NUM_COMPLETED >= 0 &&
- nComplete >= MPIR_CVAR_CH3_RMA_GC_NUM_COMPLETED) {
+ if ((MPIR_CVAR_CH3_RMA_GC_NUM_TESTED >= 0 &&
+ nVisit >= MPIR_CVAR_CH3_RMA_GC_NUM_TESTED) ||
+ (MPIR_CVAR_CH3_RMA_GC_NUM_COMPLETED >= 0 &&
+ nComplete >= MPIR_CVAR_CH3_RMA_GC_NUM_COMPLETED)) {
+ /* MPIR_CVAR_CH3_RMA_GC_NUM_TESTED: Once we tested certain
+ number of requests, we stop checking the rest of the
+ operation list and break out the loop. */
/* MPIR_CVAR_CH3_RMA_GC_NUM_COMPLETED: Once we found
certain number of completed requests, we stop checking
the rest of the operation list and break out the loop. */
@@ -5642,6 +5683,14 @@ static inline int rma_list_gc( MPID_Win *win_ptr,
else {
/* proceed to the next entry. */
curr_ptr = curr_ptr->next;
+ nVisit++;
+ if (MPIR_CVAR_CH3_RMA_GC_NUM_TESTED >= 0 &&
+ nVisit >= MPIR_CVAR_CH3_RMA_GC_NUM_TESTED) {
+ /* MPIR_CVAR_CH3_RMA_GC_NUM_TESTED: Once we tested certain
+ number of requests, we stop checking the rest of the
+ operation list and break out the loop. */
+ break;
+ }
}
} while (curr_ptr && curr_ptr != last_elm);
http://git.mpich.org/mpich.git/commitdiff/dda458a1234b02a04120c5e06654366cb11396ba
commit dda458a1234b02a04120c5e06654366cb11396ba
Author: Xin Zhao <xinzhao3 at illinois.edu>
Date: Wed Jun 4 09:50:27 2014 -0500
Add CVAR (# of completed reqs) to control when to stop in RMA GC function
Add a CVAR to let the user specify the threshold for number of
completed requests the runtime finds before it stops trying to
find more completed requests in garbage collection function. It
may make the runtime to find more completed requests, but may also
cause significant overhead due to visiting too many requests.
Note that the default value is set to 1 in order to be in
accordance with the performance of original implementation.
Note that in garbage collection function, if runtime finds a chain
of completed RMA requests, it will temporarily ignore this CVAR
and try to find continuous completed requests as many as possible,
until it meets an incomplete request.
Signed-off-by: Pavan Balaji <balaji at anl.gov>
diff --git a/src/mpid/ch3/src/ch3u_rma_sync.c b/src/mpid/ch3/src/ch3u_rma_sync.c
index c64fbe4..d9e8570 100644
--- a/src/mpid/ch3/src/ch3u_rma_sync.c
+++ b/src/mpid/ch3/src/ch3u_rma_sync.c
@@ -51,6 +51,28 @@ cvars:
but may run the risk of exceeding the available number of requests
or other internal resources.
+ - name : MPIR_CVAR_CH3_RMA_GC_NUM_COMPLETED
+ category : CH3
+ type : int
+ default : 1
+ class : none
+ verbosity : MPI_T_VERBOSITY_USER_BASIC
+ scope : MPI_T_SCOPE_ALL_EQ
+ description : >-
+ Threshold for the number of completed requests the runtime finds
+ before it stops trying to find more completed requests in garbage
+ collection function.
+ When it is set to negative value, it means runtime will not stop
+ checking the operation list until it reaches the end of the list.
+ When it is set to positive value, it means runtime will not stop
+ checking the operation list until it finds certain number of
+ completed requests. When it is set to zero value, the outcome is
+ undefined.
+ Note that in garbage collection function, if runtime finds a chain
+ of completed RMA requests, it will temporarily ignore this CVAR
+ and try to find continuous completed requests as many as possible,
+ until it meets an incomplete request.
+
- name : MPIR_CVAR_CH3_RMA_LOCK_IMMED
category : CH3
type : boolean
@@ -5609,10 +5631,13 @@ static inline int rma_list_gc( MPID_Win *win_ptr,
}
while (curr_ptr && curr_ptr != last_elm &&
MPID_Request_is_complete(curr_ptr->request)) ;
- /* Once a request completes, we wait for another
- operation to arrive rather than check the
- rest of the requests. */
+ if (MPIR_CVAR_CH3_RMA_GC_NUM_COMPLETED >= 0 &&
+ nComplete >= MPIR_CVAR_CH3_RMA_GC_NUM_COMPLETED) {
+ /* MPIR_CVAR_CH3_RMA_GC_NUM_COMPLETED: Once we found
+ certain number of completed requests, we stop checking
+ the rest of the operation list and break out the loop. */
break;
+ }
}
else {
/* proceed to the next entry. */
http://git.mpich.org/mpich.git/commitdiff/7dbdc413e346dd42121efcbfb7e4fbe2b266dab5
commit 7dbdc413e346dd42121efcbfb7e4fbe2b266dab5
Author: Xin Zhao <xinzhao3 at illinois.edu>
Date: Fri Apr 25 16:02:55 2014 -0500
Simplify RMA requests completion function
Originally rma_list_complete() function traverses the
operation list to clean up completed requests, which is
what rma_list_gc() is doing now. So we simplify
rma_list_complete() function by deleting the code of
traversing loop and just invoking rma_list_gc() in
rma_list_complete().
Signed-off-by: Pavan Balaji <balaji at anl.gov>
diff --git a/src/mpid/ch3/src/ch3u_rma_sync.c b/src/mpid/ch3/src/ch3u_rma_sync.c
index ffd9a45..c64fbe4 100644
--- a/src/mpid/ch3/src/ch3u_rma_sync.c
+++ b/src/mpid/ch3/src/ch3u_rma_sync.c
@@ -5544,41 +5544,10 @@ static inline int rma_list_complete( MPID_Win *win_ptr,
MPID_Progress_start(&progress_state);
/* Process all operations until they are complete */
while (!MPIDI_CH3I_RMA_Ops_isempty(ops_list)) {
- int loopcount = 0;
+ int nDone = 0;
+ mpi_errno = rma_list_gc(win_ptr, ops_list, NULL, &nDone);
+ if (mpi_errno != MPI_SUCCESS) MPIU_ERR_POP(mpi_errno);
ntimes++;
- curr_ptr = MPIDI_CH3I_RMA_Ops_head(ops_list);
- do {
- if (MPID_Request_is_complete(curr_ptr->request)) {
- /* Once we find a complete request, we complete
- as many as possible until we find an incomplete
- or null request */
- do {
- mpi_errno = curr_ptr->request->status.MPI_ERROR;
- /* --BEGIN ERROR HANDLING-- */
- if (mpi_errno != MPI_SUCCESS) {
- MPID_Progress_end(&progress_state);
- MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**ch3|rma_msg");
- }
- /* --END ERROR HANDLING-- */
- MPID_Request_release(curr_ptr->request);
- MPIDI_CH3I_RMA_Ops_free_and_next(ops_list, &curr_ptr);
- }
- while (curr_ptr &&
- MPID_Request_is_complete(curr_ptr->request));
- /* Once a request completes, we wait for another
- operation to arrive rather than check the
- rest of the requests. */
- break;
- }
- else {
- /* In many cases, if the list of pending requests
- is long, there's no point in checking the entire
- list */
- if (loopcount++ > 4) /* FIXME: threshold as parameter */
- break; /* wait for an event */
- curr_ptr = curr_ptr->next;
- }
- } while (curr_ptr);
/* Wait for something to arrive*/
/* In some tests, this hung unless the test ensured that
http://git.mpich.org/mpich.git/commitdiff/da7700a05be91413a8fb119d0fdf36137dbb739d
commit da7700a05be91413a8fb119d0fdf36137dbb739d
Author: Xin Zhao <xinzhao3 at illinois.edu>
Date: Fri Apr 25 15:49:41 2014 -0500
Separate progress engine code from garbage collection
Currently the code of poking progress engine to complete
requests and the code of cleanning up completed requests
are mixed up in one function rma_list_gc(), which is not
a clear code structure. We move the code of poking progress
engine out of rma_list_gc() and encapsule the code into
a separate function so that rma_list_gc() only does garbage
collection work.
Signed-off-by: Pavan Balaji <balaji at anl.gov>
diff --git a/src/mpid/ch3/src/ch3u_rma_sync.c b/src/mpid/ch3/src/ch3u_rma_sync.c
index 88a4482..ffd9a45 100644
--- a/src/mpid/ch3/src/ch3u_rma_sync.c
+++ b/src/mpid/ch3/src/ch3u_rma_sync.c
@@ -782,6 +782,7 @@ static int do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
MPIDI_CH3_Pkt_flags_t sync_flags);
static int send_lock_put_or_acc(MPID_Win *, int);
static int send_lock_get(MPID_Win *, int);
+static inline int poke_progress_engine(void);
static inline int rma_list_complete(MPID_Win *win_ptr,
MPIDI_RMA_Ops_list_t *ops_list);
static inline int rma_list_gc(MPID_Win *win_ptr,
@@ -1050,6 +1051,8 @@ int MPIDI_Win_fence(int assert, MPID_Win *win_ptr)
if (nRequest > MPIR_CVAR_CH3_RMA_NREQUEST_THRESHOLD &&
nRequest - nRequestNew > MPIR_CVAR_CH3_RMA_NREQUEST_NEW_THRESHOLD) {
int nDone = 0;
+ mpi_errno = poke_progress_engine();
+ if (mpi_errno != MPI_SUCCESS) MPIU_ERR_POP(mpi_errno);
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_winfence_complete));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_winfence_complete_aux));
@@ -2334,6 +2337,8 @@ int MPIDI_Win_complete(MPID_Win *win_ptr)
if (nRequest > MPIR_CVAR_CH3_RMA_NREQUEST_THRESHOLD &&
nRequest - nRequestNew > MPIR_CVAR_CH3_RMA_NREQUEST_NEW_THRESHOLD) {
int nDone = 0;
+ mpi_errno = poke_progress_engine();
+ if (mpi_errno != MPI_SUCCESS) MPIU_ERR_POP(mpi_errno);
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_wincomplete_complete));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_wincomplete_complete_aux));
mpi_errno = rma_list_gc(win_ptr, ops_list, curr_ptr, &nDone);
@@ -3358,6 +3363,8 @@ static int do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
if (nRequest > MPIR_CVAR_CH3_RMA_NREQUEST_THRESHOLD &&
nRequest - nRequestNew > MPIR_CVAR_CH3_RMA_NREQUEST_NEW_THRESHOLD) {
int nDone = 0;
+ mpi_errno = poke_progress_engine();
+ if (mpi_errno != MPI_SUCCESS) MPIU_ERR_POP(mpi_errno);
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_winunlock_complete));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_winunlock_complete_aux));
mpi_errno = rma_list_gc(win_ptr,
@@ -5510,6 +5517,22 @@ int MPIDI_CH3_PktHandler_Flush( MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt,
/* ------------------------------------------------------------------------ */
/* list_complete_timer/counter and list_block_timer defined above */
+static inline int poke_progress_engine(void)
+{
+ int mpi_errno = MPI_SUCCESS;
+ MPID_Progress_state progress_state;
+
+ MPID_Progress_start(&progress_state);
+ mpi_errno = MPID_Progress_poke();
+ if (mpi_errno != MPI_SUCCESS) MPIU_ERR_POP(mpi_errno);
+ MPID_Progress_end(&progress_state);
+
+ fn_exit:
+ return mpi_errno;
+ fn_fail:
+ goto fn_exit;
+}
+
static inline int rma_list_complete( MPID_Win *win_ptr,
MPIDI_RMA_Ops_list_t *ops_list )
{
@@ -5594,14 +5617,11 @@ static inline int rma_list_gc( MPID_Win *win_ptr,
{
int mpi_errno=0;
MPIDI_RMA_Op_t *curr_ptr;
- MPID_Progress_state progress_state;
int nComplete = 0;
MPIR_T_PVAR_TIMER_START_VAR(RMA, list_complete_timer);
- MPID_Progress_start(&progress_state);
curr_ptr = MPIDI_CH3I_RMA_Ops_head(ops_list);
- MPID_Progress_poke();
do {
if (MPID_Request_is_complete(curr_ptr->request)) {
/* Once we find a complete request, we complete
@@ -5612,7 +5632,6 @@ static inline int rma_list_gc( MPID_Win *win_ptr,
mpi_errno = curr_ptr->request->status.MPI_ERROR;
/* --BEGIN ERROR HANDLING-- */
if (mpi_errno != MPI_SUCCESS) {
- MPID_Progress_end(&progress_state);
MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**ch3|rma_msg");
}
/* --END ERROR HANDLING-- */
@@ -5633,7 +5652,6 @@ static inline int rma_list_gc( MPID_Win *win_ptr,
} while (curr_ptr && curr_ptr != last_elm);
/* if (nComplete) printf( "Completed %d requests\n", nComplete ); */
- MPID_Progress_end(&progress_state);
MPIR_T_PVAR_COUNTER_INC_VAR(RMA, list_complete_counter, 1);
MPIR_T_PVAR_TIMER_END_VAR(RMA, list_complete_timer);
http://git.mpich.org/mpich.git/commitdiff/73f6a4b3aa9102cd4e06f478e19f9d25df4ff3fc
commit 73f6a4b3aa9102cd4e06f478e19f9d25df4ff3fc
Author: Xin Zhao <xinzhao3 at illinois.edu>
Date: Fri Jun 20 13:49:58 2014 -0500
Rename RMA request gc and complete function
Rename RMAListPartialComplete to rma_list_gc
and rename RMAListComplete to rma_list_complete.
Declare both functions as inline function.
Add error handling code for both functions.
Signed-off-by: Pavan Balaji <balaji at anl.gov>
diff --git a/src/mpid/ch3/src/ch3u_rma_sync.c b/src/mpid/ch3/src/ch3u_rma_sync.c
index 979c41d..88a4482 100644
--- a/src/mpid/ch3/src/ch3u_rma_sync.c
+++ b/src/mpid/ch3/src/ch3u_rma_sync.c
@@ -782,9 +782,9 @@ static int do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
MPIDI_CH3_Pkt_flags_t sync_flags);
static int send_lock_put_or_acc(MPID_Win *, int);
static int send_lock_get(MPID_Win *, int);
-static int RMAListComplete(MPID_Win *win_ptr,
+static inline int rma_list_complete(MPID_Win *win_ptr,
MPIDI_RMA_Ops_list_t *ops_list);
-static int RMAListPartialComplete(MPID_Win *win_ptr,
+static inline int rma_list_gc(MPID_Win *win_ptr,
MPIDI_RMA_Ops_list_t *ops_list,
MPIDI_RMA_Op_t *last_elm, int *nDone);
@@ -1053,7 +1053,8 @@ int MPIDI_Win_fence(int assert, MPID_Win *win_ptr)
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_winfence_complete));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_winfence_complete_aux));
- RMAListPartialComplete(win_ptr, ops_list, curr_ptr, &nDone);
+ mpi_errno = rma_list_gc(win_ptr, ops_list, curr_ptr, &nDone);
+ if (mpi_errno != MPI_SUCCESS) MPIU_ERR_POP(mpi_errno);
/* if (nDone > 0) printf( "nDone = %d\n", nDone ); */
nRequest -= nDone;
nRequestNew = nRequest;
@@ -1078,7 +1079,8 @@ int MPIDI_Win_fence(int assert, MPID_Win *win_ptr)
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_winfence_complete));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_winfence_complete_aux));
MPIR_T_PVAR_STMT(RMA, list_block_timer=MPIR_T_PVAR_TIMER_ADDR(rma_winfence_block));
- mpi_errno = RMAListComplete(win_ptr, ops_list);
+ mpi_errno = rma_list_complete(win_ptr, ops_list);
+ if (mpi_errno != MPI_SUCCESS) MPIU_ERR_POP(mpi_errno);
}
MPIU_Assert(MPIDI_CH3I_RMA_Ops_isempty(ops_list));
@@ -2334,7 +2336,8 @@ int MPIDI_Win_complete(MPID_Win *win_ptr)
int nDone = 0;
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_wincomplete_complete));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_wincomplete_complete_aux));
- RMAListPartialComplete(win_ptr, ops_list, curr_ptr, &nDone);
+ mpi_errno = rma_list_gc(win_ptr, ops_list, curr_ptr, &nDone);
+ if (mpi_errno != MPI_SUCCESS) MPIU_ERR_POP(mpi_errno);
nRequest -= nDone;
nRequestNew = nRequest;
}
@@ -2403,7 +2406,8 @@ int MPIDI_Win_complete(MPID_Win *win_ptr)
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_wincomplete_complete));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_wincomplete_complete_aux));
MPIR_T_PVAR_STMT(RMA, list_block_timer=MPIR_T_PVAR_TIMER_ADDR(rma_wincomplete_block));
- mpi_errno = RMAListComplete(win_ptr, ops_list);
+ mpi_errno = rma_list_complete(win_ptr, ops_list);
+ if (mpi_errno != MPI_SUCCESS) MPIU_ERR_POP(mpi_errno);
}
MPIU_Assert(MPIDI_CH3I_RMA_Ops_isempty(ops_list));
@@ -3356,9 +3360,10 @@ static int do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
int nDone = 0;
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_winunlock_complete));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_winunlock_complete_aux));
- RMAListPartialComplete(win_ptr,
+ mpi_errno = rma_list_gc(win_ptr,
&win_ptr->targets[target_rank].rma_ops_list,
curr_ptr, &nDone);
+ if (mpi_errno != MPI_SUCCESS) MPIU_ERR_POP(mpi_errno);
/* if (nDone > 0) printf( "nDone = %d\n", nDone ); */
nRequest -= nDone;
nRequestNew = nRequest;
@@ -3372,7 +3377,8 @@ static int do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_winunlock_complete));
MPIR_T_PVAR_STMT(RMA, list_block_timer=MPIR_T_PVAR_TIMER_ADDR(rma_winunlock_block));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_winunlock_complete_aux));
- mpi_errno = RMAListComplete(win_ptr, &win_ptr->targets[target_rank].rma_ops_list);
+ mpi_errno = rma_list_complete(win_ptr, &win_ptr->targets[target_rank].rma_ops_list);
+ if (mpi_errno != MPI_SUCCESS) MPIU_ERR_POP(mpi_errno);
}
else if (sync_flags & MPIDI_CH3_PKT_FLAG_RMA_UNLOCK) {
/* No communication operations were left to process, but the RMA epoch
@@ -5504,7 +5510,7 @@ int MPIDI_CH3_PktHandler_Flush( MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt,
/* ------------------------------------------------------------------------ */
/* list_complete_timer/counter and list_block_timer defined above */
-static int RMAListComplete( MPID_Win *win_ptr,
+static inline int rma_list_complete( MPID_Win *win_ptr,
MPIDI_RMA_Ops_list_t *ops_list )
{
int ntimes = 0, mpi_errno=0;
@@ -5575,17 +5581,13 @@ static int RMAListComplete( MPID_Win *win_ptr,
return mpi_errno;
}
-/* This routine may be used to attempt to complete pending requests during
- the initial processing of the list (to handle the case where the
- communication layer is returning uncompleted requests and may run the
- danger of running out of internal data
-
- Unlike the completion routine, we call this when we expect to need a
- at least a few requests, so rather than stop looking after a few items
- (the loopcount check in the other code), we search through the entire
- list until we find a completable request.
+/* This routine is used to do garbage collection work on completed RMA
+ requests so far. It is used to clean up the RMA requests that are
+ not completed immediately when issuing out but are completed later
+ when poking progress engine, so that they will not waste internal
+ resources.
*/
-static int RMAListPartialComplete( MPID_Win *win_ptr,
+static inline int rma_list_gc( MPID_Win *win_ptr,
MPIDI_RMA_Ops_list_t *ops_list,
MPIDI_RMA_Op_t *last_elm,
int *nDone )
http://git.mpich.org/mpich.git/commitdiff/33b7d251f72bbc82d328f5c8e0c7ede0c0a9c745
commit 33b7d251f72bbc82d328f5c8e0c7ede0c0a9c745
Author: Xin Zhao <xinzhao3 at illinois.edu>
Date: Fri Apr 25 15:37:12 2014 -0500
Rename static functions in RMA code
Static functions should not have name starting with prefix "MPIDI_CH3I_".
We delete those prefix in function names as well as in state names.
Signed-off-by: Pavan Balaji <balaji at anl.gov>
diff --git a/src/mpid/ch3/src/ch3u_rma_sync.c b/src/mpid/ch3/src/ch3u_rma_sync.c
index 5a5b942..979c41d 100644
--- a/src/mpid/ch3/src/ch3u_rma_sync.c
+++ b/src/mpid/ch3/src/ch3u_rma_sync.c
@@ -754,37 +754,37 @@ static MPIR_T_pvar_timer_t *list_block_timer; /* Inner; while waiting */
#define SYNC_POST_TAG 100
-static int MPIDI_CH3I_Send_lock_msg(int dest, int lock_type, MPID_Win *win_ptr);
-static int MPIDI_CH3I_Send_unlock_msg(int dest, MPID_Win *win_ptr);
-/* static int MPIDI_CH3I_Send_flush_msg(int dest, MPID_Win *win_ptr); */
-static int MPIDI_CH3I_Wait_for_lock_granted(MPID_Win *win_ptr, int target_rank);
-static int MPIDI_CH3I_Acquire_local_lock(MPID_Win *win_ptr, int lock_mode);
-static int MPIDI_CH3I_Send_rma_msg(MPIDI_RMA_Op_t * rma_op, MPID_Win * win_ptr,
+static int send_lock_msg(int dest, int lock_type, MPID_Win *win_ptr);
+static int send_unlock_msg(int dest, MPID_Win *win_ptr);
+/* static int send_flush_msg(int dest, MPID_Win *win_ptr); */
+static int wait_for_lock_granted(MPID_Win *win_ptr, int target_rank);
+static int acquire_local_lock(MPID_Win *win_ptr, int lock_mode);
+static int send_rma_msg(MPIDI_RMA_Op_t * rma_op, MPID_Win * win_ptr,
MPIDI_CH3_Pkt_flags_t flags,
MPI_Win source_win_handle,
MPI_Win target_win_handle,
MPIDI_RMA_dtype_info * dtype_info,
void ** dataloop, MPID_Request ** request);
-static int MPIDI_CH3I_Recv_rma_msg(MPIDI_RMA_Op_t * rma_op, MPID_Win * win_ptr,
+static int recv_rma_msg(MPIDI_RMA_Op_t * rma_op, MPID_Win * win_ptr,
MPIDI_CH3_Pkt_flags_t flags,
MPI_Win source_win_handle,
MPI_Win target_win_handle,
MPIDI_RMA_dtype_info * dtype_info,
void ** dataloop, MPID_Request ** request);
-static int MPIDI_CH3I_Send_contig_acc_msg(MPIDI_RMA_Op_t *, MPID_Win *,
+static int send_contig_acc_msg(MPIDI_RMA_Op_t *, MPID_Win *,
MPIDI_CH3_Pkt_flags_t flags,
MPI_Win, MPI_Win, MPID_Request ** );
-static int MPIDI_CH3I_Send_immed_rmw_msg(MPIDI_RMA_Op_t *, MPID_Win *,
+static int send_immed_rmw_msg(MPIDI_RMA_Op_t *, MPID_Win *,
MPIDI_CH3_Pkt_flags_t flags,
MPI_Win, MPI_Win, MPID_Request ** );
-static int MPIDI_CH3I_Do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
+static int do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
int *wait_for_rma_done_pkt,
MPIDI_CH3_Pkt_flags_t sync_flags);
-static int MPIDI_CH3I_Send_lock_put_or_acc(MPID_Win *, int);
-static int MPIDI_CH3I_Send_lock_get(MPID_Win *, int);
-static int MPIDI_CH3I_RMAListComplete(MPID_Win *win_ptr,
+static int send_lock_put_or_acc(MPID_Win *, int);
+static int send_lock_get(MPID_Win *, int);
+static int RMAListComplete(MPID_Win *win_ptr,
MPIDI_RMA_Ops_list_t *ops_list);
-static int MPIDI_CH3I_RMAListPartialComplete(MPID_Win *win_ptr,
+static int RMAListPartialComplete(MPID_Win *win_ptr,
MPIDI_RMA_Ops_list_t *ops_list,
MPIDI_RMA_Op_t *last_elm, int *nDone);
@@ -804,7 +804,7 @@ static int create_datatype(const MPIDI_RMA_dtype_info *dtype_info,
case (MPIDI_RMA_PUT): \
case (MPIDI_RMA_ACCUMULATE): \
MPIDI_CH3I_TRACK_RMA_WRITE(op_ptr_, win_ptr_); \
- (err_) = MPIDI_CH3I_Send_rma_msg((op_ptr_), (win_ptr_), (flags_), (source_win_handle_), \
+ (err_) = send_rma_msg((op_ptr_), (win_ptr_), (flags_), (source_win_handle_), \
(target_win_handle_), &(op_ptr_)->dtype_info, \
&(op_ptr_)->dataloop, &(op_ptr_)->request); \
if (err_) { MPIU_ERR_POP(err_); } \
@@ -820,12 +820,12 @@ static int create_datatype(const MPIDI_RMA_dtype_info *dtype_info,
(op_ptr_)->origin_count = (op_ptr_)->result_count; \
(op_ptr_)->origin_datatype = (op_ptr_)->result_datatype; \
\
- (err_) = MPIDI_CH3I_Recv_rma_msg((op_ptr_), (win_ptr_), (flags_), (source_win_handle_), \
+ (err_) = recv_rma_msg((op_ptr_), (win_ptr_), (flags_), (source_win_handle_), \
(target_win_handle_), &(op_ptr_)->dtype_info,\
&(op_ptr_)->dataloop, &(op_ptr_)->request); \
} else { \
MPIDI_CH3I_TRACK_RMA_WRITE(op_ptr_, win_ptr_); \
- (err_) = MPIDI_CH3I_Send_rma_msg((op_ptr_), (win_ptr_), (flags_), (source_win_handle_), \
+ (err_) = send_rma_msg((op_ptr_), (win_ptr_), (flags_), (source_win_handle_), \
(target_win_handle_), &(op_ptr_)->dtype_info,\
&(op_ptr_)->dataloop, &(op_ptr_)->request); \
} \
@@ -833,13 +833,13 @@ static int create_datatype(const MPIDI_RMA_dtype_info *dtype_info,
break; \
case MPIDI_RMA_ACC_CONTIG: \
MPIDI_CH3I_TRACK_RMA_WRITE(op_ptr_, win_ptr_); \
- (err_) = MPIDI_CH3I_Send_contig_acc_msg((op_ptr_), (win_ptr_), (flags_), \
+ (err_) = send_contig_acc_msg((op_ptr_), (win_ptr_), (flags_), \
(source_win_handle_), (target_win_handle_),\
&(op_ptr_)->request ); \
if (err_) { MPIU_ERR_POP(err_); } \
break; \
case (MPIDI_RMA_GET): \
- (err_) = MPIDI_CH3I_Recv_rma_msg((op_ptr_), (win_ptr_), (flags_), \
+ (err_) = recv_rma_msg((op_ptr_), (win_ptr_), (flags_), \
(source_win_handle_), (target_win_handle_), \
&(op_ptr_)->dtype_info, \
&(op_ptr_)->dataloop, &(op_ptr_)->request); \
@@ -848,7 +848,7 @@ static int create_datatype(const MPIDI_RMA_dtype_info *dtype_info,
case (MPIDI_RMA_COMPARE_AND_SWAP): \
case (MPIDI_RMA_FETCH_AND_OP): \
MPIDI_CH3I_TRACK_RMA_WRITE(op_ptr_, win_ptr_); \
- (err_) = MPIDI_CH3I_Send_immed_rmw_msg((op_ptr_), (win_ptr_), (flags_), \
+ (err_) = send_immed_rmw_msg((op_ptr_), (win_ptr_), (flags_), \
(source_win_handle_), (target_win_handle_),\
&(op_ptr_)->request ); \
if (err_) { MPIU_ERR_POP(err_); } \
@@ -1053,7 +1053,7 @@ int MPIDI_Win_fence(int assert, MPID_Win *win_ptr)
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_winfence_complete));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_winfence_complete_aux));
- MPIDI_CH3I_RMAListPartialComplete(win_ptr, ops_list, curr_ptr, &nDone);
+ RMAListPartialComplete(win_ptr, ops_list, curr_ptr, &nDone);
/* if (nDone > 0) printf( "nDone = %d\n", nDone ); */
nRequest -= nDone;
nRequestNew = nRequest;
@@ -1078,7 +1078,7 @@ int MPIDI_Win_fence(int assert, MPID_Win *win_ptr)
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_winfence_complete));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_winfence_complete_aux));
MPIR_T_PVAR_STMT(RMA, list_block_timer=MPIR_T_PVAR_TIMER_ADDR(rma_winfence_block));
- mpi_errno = MPIDI_CH3I_RMAListComplete(win_ptr, ops_list);
+ mpi_errno = RMAListComplete(win_ptr, ops_list);
}
MPIU_Assert(MPIDI_CH3I_RMA_Ops_isempty(ops_list));
@@ -1204,10 +1204,10 @@ static int create_datatype(const MPIDI_RMA_dtype_info *dtype_info,
#undef FUNCNAME
-#define FUNCNAME MPIDI_CH3I_Send_rma_msg
+#define FUNCNAME send_rma_msg
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
-static int MPIDI_CH3I_Send_rma_msg(MPIDI_RMA_Op_t *rma_op, MPID_Win *win_ptr,
+static int send_rma_msg(MPIDI_RMA_Op_t *rma_op, MPID_Win *win_ptr,
MPIDI_CH3_Pkt_flags_t flags,
MPI_Win source_win_handle,
MPI_Win target_win_handle,
@@ -1226,10 +1226,10 @@ static int MPIDI_CH3I_Send_rma_msg(MPIDI_RMA_Op_t *rma_op, MPID_Win *win_ptr,
MPID_Datatype *target_dtp=NULL, *origin_dtp=NULL;
MPID_Request *resp_req=NULL;
MPIU_CHKPMEM_DECL(1);
- MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3I_SEND_RMA_MSG);
+ MPIDI_STATE_DECL(MPID_STATE_SEND_RMA_MSG);
MPIDI_STATE_DECL(MPID_STATE_MEMCPY);
- MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_SEND_RMA_MSG);
+ MPIDI_RMA_FUNC_ENTER(MPID_STATE_SEND_RMA_MSG);
*request = NULL;
@@ -1493,7 +1493,7 @@ static int MPIDI_CH3I_Send_rma_msg(MPIDI_RMA_Op_t *rma_op, MPID_Win *win_ptr,
fn_exit:
MPIU_CHKPMEM_COMMIT();
- MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_CH3I_SEND_RMA_MSG);
+ MPIDI_RMA_FUNC_EXIT(MPID_STATE_SEND_RMA_MSG);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
fn_fail:
@@ -1516,10 +1516,10 @@ static int MPIDI_CH3I_Send_rma_msg(MPIDI_RMA_Op_t *rma_op, MPID_Win *win_ptr,
* Use this for contiguous accumulate operations
*/
#undef FUNCNAME
-#define FUNCNAME MPIDI_CH3I_Send_contig_acc_msg
+#define FUNCNAME send_contig_acc_msg
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
-static int MPIDI_CH3I_Send_contig_acc_msg(MPIDI_RMA_Op_t *rma_op,
+static int send_contig_acc_msg(MPIDI_RMA_Op_t *rma_op,
MPID_Win *win_ptr,
MPIDI_CH3_Pkt_flags_t flags,
MPI_Win source_win_handle,
@@ -1535,9 +1535,9 @@ static int MPIDI_CH3I_Send_contig_acc_msg(MPIDI_RMA_Op_t *rma_op,
MPIDI_VC_t * vc;
MPID_Comm *comm_ptr;
size_t len;
- MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3I_SEND_CONTIG_ACC_MSG);
+ MPIDI_STATE_DECL(MPID_STATE_SEND_CONTIG_ACC_MSG);
- MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_SEND_CONTIG_ACC_MSG);
+ MPIDI_RMA_FUNC_ENTER(MPID_STATE_SEND_CONTIG_ACC_MSG);
*request = NULL;
@@ -1613,7 +1613,7 @@ static int MPIDI_CH3I_Send_contig_acc_msg(MPIDI_RMA_Op_t *rma_op,
MPIU_ERR_CHKANDJUMP(mpi_errno, mpi_errno, MPI_ERR_OTHER, "**ch3|rmamsg");
fn_exit:
- MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_CH3I_SEND_CONTIG_ACC_MSG);
+ MPIDI_RMA_FUNC_EXIT(MPID_STATE_SEND_CONTIG_ACC_MSG);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
fn_fail:
@@ -1631,10 +1631,10 @@ static int MPIDI_CH3I_Send_contig_acc_msg(MPIDI_RMA_Op_t *rma_op,
* Initiate an immediate RMW accumulate operation
*/
#undef FUNCNAME
-#define FUNCNAME MPIDI_CH3I_Send_immed_rmw_msg
+#define FUNCNAME send_immed_rmw_msg
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
-static int MPIDI_CH3I_Send_immed_rmw_msg(MPIDI_RMA_Op_t *rma_op,
+static int send_immed_rmw_msg(MPIDI_RMA_Op_t *rma_op,
MPID_Win *win_ptr,
MPIDI_CH3_Pkt_flags_t flags,
MPI_Win source_win_handle,
@@ -1646,9 +1646,9 @@ static int MPIDI_CH3I_Send_immed_rmw_msg(MPIDI_RMA_Op_t *rma_op,
MPIDI_VC_t *vc;
MPID_Comm *comm_ptr;
MPI_Aint len;
- MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3I_SEND_IMMED_RMW_MSG);
+ MPIDI_STATE_DECL(MPID_STATE_SEND_IMMED_RMW_MSG);
- MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_SEND_IMMED_RMW_MSG);
+ MPIDI_RMA_FUNC_ENTER(MPID_STATE_SEND_IMMED_RMW_MSG);
*request = NULL;
@@ -1764,7 +1764,7 @@ static int MPIDI_CH3I_Send_immed_rmw_msg(MPIDI_RMA_Op_t *rma_op,
}
fn_exit:
- MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_CH3I_SEND_IMMED_RMW_MSG);
+ MPIDI_RMA_FUNC_EXIT(MPID_STATE_SEND_IMMED_RMW_MSG);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
fn_fail:
@@ -1782,10 +1782,10 @@ fn_fail:
#undef FUNCNAME
-#define FUNCNAME MPIDI_CH3I_Recv_rma_msg
+#define FUNCNAME recv_rma_msg
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
-static int MPIDI_CH3I_Recv_rma_msg(MPIDI_RMA_Op_t *rma_op, MPID_Win *win_ptr,
+static int recv_rma_msg(MPIDI_RMA_Op_t *rma_op, MPID_Win *win_ptr,
MPIDI_CH3_Pkt_flags_t flags,
MPI_Win source_win_handle,
MPI_Win target_win_handle,
@@ -1801,10 +1801,10 @@ static int MPIDI_CH3I_Recv_rma_msg(MPIDI_RMA_Op_t *rma_op, MPID_Win *win_ptr,
MPID_Datatype *dtp;
MPID_IOV iov[MPID_IOV_LIMIT];
MPIU_CHKPMEM_DECL(1);
- MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3I_RECV_RMA_MSG);
+ MPIDI_STATE_DECL(MPID_STATE_RECV_RMA_MSG);
MPIDI_STATE_DECL(MPID_STATE_MEMCPY);
- MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_RECV_RMA_MSG);
+ MPIDI_RMA_FUNC_ENTER(MPID_STATE_RECV_RMA_MSG);
/* create a request, store the origin buf, cnt, datatype in it,
and pass a handle to it in the get packet. When the get
@@ -1917,7 +1917,7 @@ static int MPIDI_CH3I_Recv_rma_msg(MPIDI_RMA_Op_t *rma_op, MPID_Win *win_ptr,
}
fn_exit:
- MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_CH3I_RECV_RMA_MSG);
+ MPIDI_RMA_FUNC_EXIT(MPID_STATE_RECV_RMA_MSG);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
@@ -2334,7 +2334,7 @@ int MPIDI_Win_complete(MPID_Win *win_ptr)
int nDone = 0;
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_wincomplete_complete));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_wincomplete_complete_aux));
- MPIDI_CH3I_RMAListPartialComplete(win_ptr, ops_list, curr_ptr, &nDone);
+ RMAListPartialComplete(win_ptr, ops_list, curr_ptr, &nDone);
nRequest -= nDone;
nRequestNew = nRequest;
}
@@ -2403,7 +2403,7 @@ int MPIDI_Win_complete(MPID_Win *win_ptr)
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_wincomplete_complete));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_wincomplete_complete_aux));
MPIR_T_PVAR_STMT(RMA, list_block_timer=MPIR_T_PVAR_TIMER_ADDR(rma_wincomplete_block));
- mpi_errno = MPIDI_CH3I_RMAListComplete(win_ptr, ops_list);
+ mpi_errno = RMAListComplete(win_ptr, ops_list);
}
MPIU_Assert(MPIDI_CH3I_RMA_Ops_isempty(ops_list));
@@ -2582,7 +2582,7 @@ int MPIDI_Win_lock(int lock_type, int dest, int assert, MPID_Win *win_ptr)
/* The target is this process itself. We must block until the lock
* is acquired. Once it is acquired, local puts, gets, accumulates
* will be done directly without queueing. */
- mpi_errno = MPIDI_CH3I_Acquire_local_lock(win_ptr, lock_type);
+ mpi_errno = acquire_local_lock(win_ptr, lock_type);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
}
else if (win_ptr->shm_allocated == TRUE) {
@@ -2604,17 +2604,17 @@ int MPIDI_Win_lock(int lock_type, int dest, int assert, MPID_Win *win_ptr)
}
if (win_ptr->create_flavor == MPI_WIN_FLAVOR_SHARED || orig_vc->node_id == target_vc->node_id) {
- mpi_errno = MPIDI_CH3I_Send_lock_msg(dest, lock_type, win_ptr);
+ mpi_errno = send_lock_msg(dest, lock_type, win_ptr);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
- mpi_errno = MPIDI_CH3I_Wait_for_lock_granted(win_ptr, dest);
+ mpi_errno = wait_for_lock_granted(win_ptr, dest);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
}
}
else if (MPIR_CVAR_CH3_RMA_LOCK_IMMED && ((assert & MPI_MODE_NOCHECK) == 0)) {
/* TODO: Make this mode of operation available through an assert
argument or info key. */
- mpi_errno = MPIDI_CH3I_Send_lock_msg(dest, lock_type, win_ptr);
+ mpi_errno = send_lock_msg(dest, lock_type, win_ptr);
MPIU_ERR_CHKANDJUMP(mpi_errno != MPI_SUCCESS, mpi_errno, MPI_ERR_OTHER, "**ch3|rma_msg");
}
@@ -2720,11 +2720,11 @@ int MPIDI_Win_unlock(int dest, MPID_Win *win_ptr)
/* Set the lock granted flag to 1 */
win_ptr->targets[dest].remote_lock_state = MPIDI_CH3_WIN_LOCK_GRANTED;
if (curr_op->type == MPIDI_RMA_GET) {
- mpi_errno = MPIDI_CH3I_Send_lock_get(win_ptr, dest);
+ mpi_errno = send_lock_get(win_ptr, dest);
wait_for_rma_done_pkt = 0;
}
else {
- mpi_errno = MPIDI_CH3I_Send_lock_put_or_acc(win_ptr, dest);
+ mpi_errno = send_lock_put_or_acc(win_ptr, dest);
wait_for_rma_done_pkt = 1;
}
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
@@ -2740,19 +2740,19 @@ int MPIDI_Win_unlock(int dest, MPID_Win *win_ptr)
if ((win_ptr->targets[dest].remote_lock_assert & MPI_MODE_NOCHECK) == 0)
{
if (win_ptr->targets[dest].remote_lock_state == MPIDI_CH3_WIN_LOCK_CALLED) {
- mpi_errno = MPIDI_CH3I_Send_lock_msg(dest, win_ptr->targets[dest].remote_lock_mode,
+ mpi_errno = send_lock_msg(dest, win_ptr->targets[dest].remote_lock_mode,
win_ptr);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
}
}
if (win_ptr->targets[dest].remote_lock_state == MPIDI_CH3_WIN_LOCK_REQUESTED) {
- mpi_errno = MPIDI_CH3I_Wait_for_lock_granted(win_ptr, dest);
+ mpi_errno = wait_for_lock_granted(win_ptr, dest);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
}
/* Now do all the RMA operations */
- mpi_errno = MPIDI_CH3I_Do_passive_target_rma(win_ptr, dest, &wait_for_rma_done_pkt,
+ mpi_errno = do_passive_target_rma(win_ptr, dest, &wait_for_rma_done_pkt,
MPIDI_CH3_PKT_FLAG_RMA_UNLOCK);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
}
@@ -2925,17 +2925,17 @@ int MPIDI_Win_flush(int rank, MPID_Win *win_ptr)
reply, and perform the RMA ops. */
if (win_ptr->targets[rank].remote_lock_state == MPIDI_CH3_WIN_LOCK_CALLED) {
- mpi_errno = MPIDI_CH3I_Send_lock_msg(rank, win_ptr->targets[rank].remote_lock_mode, win_ptr);
+ mpi_errno = send_lock_msg(rank, win_ptr->targets[rank].remote_lock_mode, win_ptr);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
}
if (win_ptr->targets[rank].remote_lock_state != MPIDI_CH3_WIN_LOCK_GRANTED) {
- mpi_errno = MPIDI_CH3I_Wait_for_lock_granted(win_ptr, rank);
+ mpi_errno = wait_for_lock_granted(win_ptr, rank);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
}
win_ptr->targets[rank].remote_lock_state = MPIDI_CH3_WIN_LOCK_FLUSH;
- mpi_errno = MPIDI_CH3I_Do_passive_target_rma(win_ptr, rank, &wait_for_rma_done_pkt,
+ mpi_errno = do_passive_target_rma(win_ptr, rank, &wait_for_rma_done_pkt,
MPIDI_CH3_PKT_FLAG_RMA_FLUSH);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
@@ -3075,7 +3075,7 @@ int MPIDI_Win_lock_all(int assert, MPID_Win *win_ptr)
}
/* Immediately lock the local process for load/store access */
- mpi_errno = MPIDI_CH3I_Acquire_local_lock(win_ptr, MPI_LOCK_SHARED);
+ mpi_errno = acquire_local_lock(win_ptr, MPI_LOCK_SHARED);
if (mpi_errno != MPI_SUCCESS) { MPIU_ERR_POP(mpi_errno); }
if (win_ptr->shm_allocated == TRUE) {
@@ -3100,7 +3100,7 @@ int MPIDI_Win_lock_all(int assert, MPID_Win *win_ptr)
}
if (win_ptr->create_flavor == MPI_WIN_FLAVOR_SHARED || orig_vc->node_id == target_vc->node_id) {
- mpi_errno = MPIDI_CH3I_Send_lock_msg(i, MPI_LOCK_SHARED, win_ptr);
+ mpi_errno = send_lock_msg(i, MPI_LOCK_SHARED, win_ptr);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
}
}
@@ -3115,7 +3115,7 @@ int MPIDI_Win_lock_all(int assert, MPID_Win *win_ptr)
}
if (win_ptr->create_flavor == MPI_WIN_FLAVOR_SHARED || orig_vc->node_id == target_vc->node_id) {
- mpi_errno = MPIDI_CH3I_Wait_for_lock_granted(win_ptr, i);
+ mpi_errno = wait_for_lock_granted(win_ptr, i);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
}
}
@@ -3195,19 +3195,19 @@ int MPIDI_Win_sync(MPID_Win *win_ptr)
#undef FUNCNAME
-#define FUNCNAME MPIDI_CH3I_Do_passive_target_rma
+#define FUNCNAME do_passive_target_rma
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
-static int MPIDI_CH3I_Do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
+static int do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
int *wait_for_rma_done_pkt, MPIDI_CH3_Pkt_flags_t sync_flags)
{
int mpi_errno = MPI_SUCCESS, nops;
MPIDI_RMA_Op_t *curr_ptr;
MPI_Win source_win_handle = MPI_WIN_NULL, target_win_handle = MPI_WIN_NULL;
int nRequest=0, nRequestNew=0;
- MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3I_DO_PASSIVE_TARGET_RMA);
+ MPIDI_STATE_DECL(MPID_STATE_DO_PASSIVE_TARGET_RMA);
- MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_DO_PASSIVE_TARGET_RMA);
+ MPIDI_RMA_FUNC_ENTER(MPID_STATE_DO_PASSIVE_TARGET_RMA);
MPIU_Assert(win_ptr->targets[target_rank].remote_lock_state == MPIDI_CH3_WIN_LOCK_GRANTED ||
win_ptr->targets[target_rank].remote_lock_state == MPIDI_CH3_WIN_LOCK_FLUSH ||
@@ -3356,7 +3356,7 @@ static int MPIDI_CH3I_Do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
int nDone = 0;
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_winunlock_complete));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_winunlock_complete_aux));
- MPIDI_CH3I_RMAListPartialComplete(win_ptr,
+ RMAListPartialComplete(win_ptr,
&win_ptr->targets[target_rank].rma_ops_list,
curr_ptr, &nDone);
/* if (nDone > 0) printf( "nDone = %d\n", nDone ); */
@@ -3372,12 +3372,12 @@ static int MPIDI_CH3I_Do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
MPIR_T_PVAR_STMT(RMA, list_complete_timer=MPIR_T_PVAR_TIMER_ADDR(rma_winunlock_complete));
MPIR_T_PVAR_STMT(RMA, list_block_timer=MPIR_T_PVAR_TIMER_ADDR(rma_winunlock_block));
MPIR_T_PVAR_STMT(RMA, list_complete_counter=MPIR_T_PVAR_COUNTER_ADDR(rma_winunlock_complete_aux));
- mpi_errno = MPIDI_CH3I_RMAListComplete(win_ptr, &win_ptr->targets[target_rank].rma_ops_list);
+ mpi_errno = RMAListComplete(win_ptr, &win_ptr->targets[target_rank].rma_ops_list);
}
else if (sync_flags & MPIDI_CH3_PKT_FLAG_RMA_UNLOCK) {
/* No communication operations were left to process, but the RMA epoch
is open. Send an unlock message to release the lock at the target. */
- mpi_errno = MPIDI_CH3I_Send_unlock_msg(target_rank, win_ptr);
+ mpi_errno = send_unlock_msg(target_rank, win_ptr);
if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
*wait_for_rma_done_pkt = 1;
}
@@ -3387,7 +3387,7 @@ static int MPIDI_CH3I_Do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
MPIU_Assert(MPIDI_CH3I_RMA_Ops_isempty(&win_ptr->targets[target_rank].rma_ops_list));
fn_exit:
- MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_CH3I_DO_PASSIVE_TARGET_RMA);
+ MPIDI_RMA_FUNC_EXIT(MPID_STATE_DO_PASSIVE_TARGET_RMA);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
fn_fail:
@@ -3397,17 +3397,17 @@ static int MPIDI_CH3I_Do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
#undef FUNCNAME
-#define FUNCNAME MPIDI_CH3I_Send_lock_msg
+#define FUNCNAME send_lock_msg
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
-static int MPIDI_CH3I_Send_lock_msg(int dest, int lock_type, MPID_Win *win_ptr) {
+static int send_lock_msg(int dest, int lock_type, MPID_Win *win_ptr) {
int mpi_errno = MPI_SUCCESS;
MPIDI_CH3_Pkt_t upkt;
MPIDI_CH3_Pkt_lock_t *lock_pkt = &upkt.lock;
MPID_Request *req=NULL;
MPIDI_VC_t *vc;
- MPIDI_STATE_DECL(MPID_STATE_MPIDI_SEND_LOCK_MSG);
- MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_SEND_LOCK_MSG);
+ MPIDI_STATE_DECL(MPID_STATE_SEND_LOCK_MSG);
+ MPIDI_RMA_FUNC_ENTER(MPID_STATE_SEND_LOCK_MSG);
MPIU_Assert(win_ptr->targets[dest].remote_lock_state == MPIDI_CH3_WIN_LOCK_CALLED);
@@ -3432,7 +3432,7 @@ static int MPIDI_CH3I_Send_lock_msg(int dest, int lock_type, MPID_Win *win_ptr)
}
fn_exit:
- MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_SEND_LOCK_MSG);
+ MPIDI_RMA_FUNC_EXIT(MPID_STATE_SEND_LOCK_MSG);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
fn_fail:
@@ -3442,13 +3442,13 @@ static int MPIDI_CH3I_Send_lock_msg(int dest, int lock_type, MPID_Win *win_ptr)
#undef FUNCNAME
-#define FUNCNAME MPIDI_CH3I_Acquire_local_lock
+#define FUNCNAME acquire_local_lock
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
-static int MPIDI_CH3I_Acquire_local_lock(MPID_Win *win_ptr, int lock_type) {
+static int acquire_local_lock(MPID_Win *win_ptr, int lock_type) {
int mpi_errno = MPI_SUCCESS;
- MPIDI_STATE_DECL(MPID_STATE_MPIDI_ACQUIRE_LOCAL_LOCK);
- MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_ACQUIRE_LOCAL_LOCK);
+ MPIDI_STATE_DECL(MPID_STATE_ACQUIRE_LOCAL_LOCK);
+ MPIDI_RMA_FUNC_ENTER(MPID_STATE_ACQUIRE_LOCAL_LOCK);
/* poke the progress engine until the local lock is granted */
if (MPIDI_CH3I_Try_acquire_win_lock(win_ptr, lock_type) == 0)
@@ -3475,7 +3475,7 @@ static int MPIDI_CH3I_Acquire_local_lock(MPID_Win *win_ptr, int lock_type) {
win_ptr->targets[win_ptr->comm_ptr->rank].remote_lock_mode = lock_type;
fn_exit:
- MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_ACQUIRE_LOCAL_LOCK);
+ MPIDI_RMA_FUNC_EXIT(MPID_STATE_ACQUIRE_LOCAL_LOCK);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
fn_fail:
@@ -3485,13 +3485,13 @@ fn_fail:
#undef FUNCNAME
-#define FUNCNAME MPIDI_CH3I_Wait_for_lock_granted
+#define FUNCNAME wait_for_lock_granted
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
-static int MPIDI_CH3I_Wait_for_lock_granted(MPID_Win *win_ptr, int target_rank) {
+static int wait_for_lock_granted(MPID_Win *win_ptr, int target_rank) {
int mpi_errno = MPI_SUCCESS;
- MPIDI_STATE_DECL(MPID_STATE_MPIDI_WAIT_FOR_LOCK_GRANTED);
- MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_WAIT_FOR_LOCK_GRANTED);
+ MPIDI_STATE_DECL(MPID_STATE_WAIT_FOR_LOCK_GRANTED);
+ MPIDI_RMA_FUNC_ENTER(MPID_STATE_WAIT_FOR_LOCK_GRANTED);
/* After the target grants the lock, it sends a lock_granted packet. This
* packet is received in ch3u_handle_recv_pkt.c. The handler for the
@@ -3521,7 +3521,7 @@ static int MPIDI_CH3I_Wait_for_lock_granted(MPID_Win *win_ptr, int target_rank)
}
fn_exit:
- MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_WAIT_FOR_LOCK_GRANTED);
+ MPIDI_RMA_FUNC_EXIT(MPID_STATE_WAIT_FOR_LOCK_GRANTED);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
fn_fail:
@@ -3531,17 +3531,17 @@ fn_fail:
#undef FUNCNAME
-#define FUNCNAME MPIDI_CH3I_Send_unlock_msg
+#define FUNCNAME send_unlock_msg
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
-static int MPIDI_CH3I_Send_unlock_msg(int dest, MPID_Win *win_ptr) {
+static int send_unlock_msg(int dest, MPID_Win *win_ptr) {
int mpi_errno = MPI_SUCCESS;
MPIDI_CH3_Pkt_t upkt;
MPIDI_CH3_Pkt_unlock_t *unlock_pkt = &upkt.unlock;
MPID_Request *req=NULL;
MPIDI_VC_t *vc;
- MPIDI_STATE_DECL(MPID_STATE_MPIDI_SEND_UNLOCK_MSG);
- MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_SEND_UNLOCK_MSG);
+ MPIDI_STATE_DECL(MPID_STATE_SEND_UNLOCK_MSG);
+ MPIDI_RMA_FUNC_ENTER(MPID_STATE_SEND_UNLOCK_MSG);
MPIU_Assert(win_ptr->targets[dest].remote_lock_state == MPIDI_CH3_WIN_LOCK_GRANTED);
@@ -3567,7 +3567,7 @@ static int MPIDI_CH3I_Send_unlock_msg(int dest, MPID_Win *win_ptr) {
}
fn_exit:
- MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_SEND_UNLOCK_MSG);
+ MPIDI_RMA_FUNC_EXIT(MPID_STATE_SEND_UNLOCK_MSG);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
fn_fail:
@@ -3580,17 +3580,17 @@ static int MPIDI_CH3I_Send_unlock_msg(int dest, MPID_Win *win_ptr) {
* for later use. */
#if 0
#undef FUNCNAME
-#define FUNCNAME MPIDI_CH3I_Send_flush_msg
+#define FUNCNAME send_flush_msg
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
-static int MPIDI_CH3I_Send_flush_msg(int dest, MPID_Win *win_ptr) {
+static int send_flush_msg(int dest, MPID_Win *win_ptr) {
int mpi_errno = MPI_SUCCESS;
MPIDI_CH3_Pkt_t upkt;
MPIDI_CH3_Pkt_flush_t *flush_pkt = &upkt.flush;
MPID_Request *req=NULL;
MPIDI_VC_t *vc;
- MPIDI_STATE_DECL(MPID_STATE_MPIDI_SEND_FLUSH_MSG);
- MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_SEND_FLUSH_MSG);
+ MPIDI_STATE_DECL(MPID_STATE_SEND_FLUSH_MSG);
+ MPIDI_RMA_FUNC_ENTER(MPID_STATE_SEND_FLUSH_MSG);
MPIU_Assert(win_ptr->targets[dest].remote_lock_state == MPIDI_CH3_WIN_LOCK_FLUSH);
@@ -3611,7 +3611,7 @@ static int MPIDI_CH3I_Send_flush_msg(int dest, MPID_Win *win_ptr) {
}
fn_exit:
- MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_SEND_FLUSH_MSG);
+ MPIDI_RMA_FUNC_EXIT(MPID_STATE_SEND_FLUSH_MSG);
return mpi_errno;
/* --BEGIN ERROR HANDLING-- */
fn_fail:
@@ -3622,10 +3622,10 @@ static int MPIDI_CH3I_Send_flush_msg(int dest, MPID_Win *win_ptr) {
#undef FUNCNAME
-#define FUNCNAME MPIDI_CH3I_Send_lock_put_or_acc
+#define FUNCNAME send_lock_put_or_acc
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
-static int MPIDI_CH3I_Send_lock_put_or_acc(MPID_Win *win_ptr, int target_rank)
+static int send_lock_put_or_acc(MPID_Win *win_ptr, int target_rank)
{
int mpi_errno=MPI_SUCCESS, lock_type, origin_dt_derived, iovcnt;
MPIDI_RMA_Op_t *rma_op;
@@ -3641,9 +3641,9 @@ static int MPIDI_CH3I_Send_lock_put_or_acc(MPID_Win *win_ptr, int target_rank)
MPIDI_CH3_Pkt_lock_accum_unlock_t *lock_accum_unlock_pkt =
&upkt.lock_accum_unlock;
- MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3I_SEND_LOCK_PUT_OR_ACC);
+ MPIDI_STATE_DECL(MPID_STATE_SEND_LOCK_PUT_OR_ACC);
- MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_SEND_LOCK_PUT_OR_ACC);
+ MPIDI_RMA_FUNC_ENTER(MPID_STATE_SEND_LOCK_PUT_OR_ACC);
lock_type = win_ptr->targets[target_rank].remote_lock_mode;
@@ -3821,16 +3821,16 @@ static int MPIDI_CH3I_Send_lock_put_or_acc(MPID_Win *win_ptr, int target_rank)
MPIDI_CH3I_RMA_Ops_free(&win_ptr->targets[target_rank].rma_ops_list);
fn_fail:
- MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_CH3I_SEND_LOCK_PUT_OR_ACC);
+ MPIDI_RMA_FUNC_EXIT(MPID_STATE_SEND_LOCK_PUT_OR_ACC);
return mpi_errno;
}
#undef FUNCNAME
-#define FUNCNAME MPIDI_CH3I_Send_lock_get
+#define FUNCNAME send_lock_get
#undef FCNAME
#define FCNAME MPIDI_QUOTE(FUNCNAME)
-static int MPIDI_CH3I_Send_lock_get(MPID_Win *win_ptr, int target_rank)
+static int send_lock_get(MPID_Win *win_ptr, int target_rank)
{
int mpi_errno=MPI_SUCCESS, lock_type;
MPIDI_RMA_Op_t *rma_op;
@@ -3842,9 +3842,9 @@ static int MPIDI_CH3I_Send_lock_get(MPID_Win *win_ptr, int target_rank)
MPIDI_CH3_Pkt_lock_get_unlock_t *lock_get_unlock_pkt =
&upkt.lock_get_unlock;
- MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3I_SEND_LOCK_GET);
+ MPIDI_STATE_DECL(MPID_STATE_SEND_LOCK_GET);
- MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_SEND_LOCK_GET);
+ MPIDI_RMA_FUNC_ENTER(MPID_STATE_SEND_LOCK_GET);
lock_type = win_ptr->targets[target_rank].remote_lock_mode;
@@ -3941,7 +3941,7 @@ static int MPIDI_CH3I_Send_lock_get(MPID_Win *win_ptr, int target_rank)
MPIDI_CH3I_RMA_Ops_free(&win_ptr->targets[target_rank].rma_ops_list);
fn_fail:
- MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_CH3I_SEND_LOCK_GET);
+ MPIDI_RMA_FUNC_EXIT(MPID_STATE_SEND_LOCK_GET);
return mpi_errno;
}
@@ -5504,7 +5504,7 @@ int MPIDI_CH3_PktHandler_Flush( MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt,
/* ------------------------------------------------------------------------ */
/* list_complete_timer/counter and list_block_timer defined above */
-static int MPIDI_CH3I_RMAListComplete( MPID_Win *win_ptr,
+static int RMAListComplete( MPID_Win *win_ptr,
MPIDI_RMA_Ops_list_t *ops_list )
{
int ntimes = 0, mpi_errno=0;
@@ -5585,7 +5585,7 @@ static int MPIDI_CH3I_RMAListComplete( MPID_Win *win_ptr,
(the loopcount check in the other code), we search through the entire
list until we find a completable request.
*/
-static int MPIDI_CH3I_RMAListPartialComplete( MPID_Win *win_ptr,
+static int RMAListPartialComplete( MPID_Win *win_ptr,
MPIDI_RMA_Ops_list_t *ops_list,
MPIDI_RMA_Op_t *last_elm,
int *nDone )
-----------------------------------------------------------------------
Summary of changes:
src/mpid/ch3/src/ch3u_rma_sync.c | 373 ++++++++++++++++++++++----------------
1 files changed, 218 insertions(+), 155 deletions(-)
hooks/post-receive
--
MPICH primary repository
More information about the commits
mailing list