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 0e945ae71025b195bb1211407785ebd2c7817776 (commit) via aa36f043253d93e11a1de3c8fa10410de72e7a3d (commit) via 32596b62b8d4b85cca3424a85fae216843b20e06 (commit) from 52a42c266c6d5610a99ed14b0d82c3d392a8df8e (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/0e945ae71025b195bb1211407785ebd2c7... commit 0e945ae71025b195bb1211407785ebd2c7817776 Author: Xin Zhao <[email protected]> Date: Thu Sep 25 14:18:53 2014 -0500 Add a RMA test for target side completion in Active Target. In this test, during Active Target epoch, the origin process issues a large GET operation followed by a small PUT operation to the target process. Win_wait / Win_fence should guarantee all operations are completed at target when they returns. So after they return, we make the target process to update one window location accessed by that GET before. The GET operation should not get the updated value. Signed-off-by: Pavan Balaji <[email protected]> diff --git a/test/mpi/rma/Makefile.am b/test/mpi/rma/Makefile.am index 5975aea..13529c3 100644 --- a/test/mpi/rma/Makefile.am +++ b/test/mpi/rma/Makefile.am @@ -136,7 +136,8 @@ noinst_PROGRAMS = \ nb_test \ acc-loc \ fence_shm \ - get-struct + get-struct \ + at_complete strided_acc_indexed_LDADD = $(LDADD) -lm strided_acc_onelock_LDADD = $(LDADD) -lm diff --git a/test/mpi/rma/at_complete.c b/test/mpi/rma/at_complete.c new file mode 100644 index 0000000..9ba38a3 --- /dev/null +++ b/test/mpi/rma/at_complete.c @@ -0,0 +1,129 @@ +/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */ +/* + * (C) 2014 by Argonne National Laboratory. + * See COPYRIGHT in top-level directory. + */ + +#include <stdio.h> +#include <mpi.h> + +#define PUT_SIZE 1 +#define GET_SIZE 100000 +#define WIN_SIZE (PUT_SIZE+GET_SIZE) +#define LOOP 100 + +int main (int argc, char **argv) { + MPI_Win win; + int i, k, rank, nproc; + int win_buf[WIN_SIZE], orig_get_buf[GET_SIZE], orig_put_buf[PUT_SIZE]; + int orig_rank = 0, dest_rank = 1; + int errors = 0; + MPI_Group comm_group, orig_group, dest_group; + + MPI_Init(&argc, &argv); + + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + MPI_Comm_size(MPI_COMM_WORLD, &nproc); + + MPI_Comm_group(MPI_COMM_WORLD, &comm_group); + MPI_Group_incl(comm_group, 1, &orig_rank, &orig_group); + MPI_Group_incl(comm_group, 1, &dest_rank, &dest_group); + + for (i = 0; i < PUT_SIZE; i++) orig_put_buf[i] = 1; + for (i = 0; i < GET_SIZE; i++) orig_get_buf[i] = 0; + for (i = 0; i < WIN_SIZE; i++) win_buf[i] = 1; + + MPI_Win_create(win_buf, sizeof(int) * WIN_SIZE, sizeof(int), MPI_INFO_NULL, + MPI_COMM_WORLD, &win); + + for (k = 0; k < LOOP; k++) { + + /* test for FENCE */ + + if (rank == orig_rank) { + MPI_Win_fence(MPI_MODE_NOPRECEDE, win); + MPI_Get(orig_get_buf, GET_SIZE, MPI_INT, + dest_rank, PUT_SIZE/*disp*/, GET_SIZE, MPI_INT, win); + MPI_Put(orig_put_buf, PUT_SIZE, MPI_INT, + dest_rank, 0/*disp*/, PUT_SIZE, MPI_INT, win); + MPI_Win_fence(MPI_MODE_NOSUCCEED, win); + + /* check GET result values */ + for (i = 0; i < GET_SIZE; i++) { + if (orig_get_buf[i] != 1) { + printf("LOOP=%d, FENCE, orig_get_buf[%d] = %d, expected 1.\n", + k, i, orig_get_buf[i]); + errors++; + } + } + } else if (rank == dest_rank) { + MPI_Win_fence(MPI_MODE_NOPRECEDE, win); + MPI_Win_fence(MPI_MODE_NOSUCCEED, win); + + /* modify the last element in window */ + MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win); + win_buf[WIN_SIZE-1] = 2; + MPI_Win_unlock(rank, win); + } + + MPI_Barrier(MPI_COMM_WORLD); + /* reset buffers */ + for (i = 0; i < PUT_SIZE; i++) orig_put_buf[i] = 1; + for (i = 0; i < GET_SIZE; i++) orig_get_buf[i] = 0; + MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win); + for (i = 0; i < WIN_SIZE; i++) win_buf[i] = 1; + MPI_Win_unlock(rank, win); + MPI_Barrier(MPI_COMM_WORLD); + + /* test for PSCW */ + + if (rank == orig_rank) { + MPI_Win_start(dest_group, 0, win); + MPI_Get(orig_get_buf, GET_SIZE, MPI_INT, + dest_rank, PUT_SIZE/*disp*/, GET_SIZE, MPI_INT, win); + MPI_Put(orig_put_buf, PUT_SIZE, MPI_INT, + dest_rank, 0/*disp*/, PUT_SIZE, MPI_INT, win); + MPI_Win_complete(win); + + /* check GET result values */ + for (i = 0; i < GET_SIZE; i++) { + if (orig_get_buf[i] != 1) { + printf("LOOP=%d, PSCW, orig_get_buf[%d] = %d, expected 1.\n", + k, i, orig_get_buf[i]); + errors++; + } + } + } + else if (rank == dest_rank) { + MPI_Win_post(orig_group, 0, win); + MPI_Win_wait(win); + + /* modify the last element in window */ + MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win); + win_buf[WIN_SIZE-1] = 2; + MPI_Win_unlock(rank, win); + } + + MPI_Barrier(MPI_COMM_WORLD); + /* reset buffers */ + for (i = 0; i < PUT_SIZE; i++) orig_put_buf[i] = 1; + for (i = 0; i < GET_SIZE; i++) orig_get_buf[i] = 0; + MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, win); + for (i = 0; i < WIN_SIZE; i++) win_buf[i] = 1; + MPI_Win_unlock(rank, win); + MPI_Barrier(MPI_COMM_WORLD); + } + + MPI_Win_free(&win); + + MPI_Group_free(&orig_group); + MPI_Group_free(&dest_group); + MPI_Group_free(&comm_group); + + if (rank == orig_rank && errors == 0) { + printf(" No Errors\n"); + } + + MPI_Finalize(); + return 0; +} diff --git a/test/mpi/rma/testlist.in b/test/mpi/rma/testlist.in index cd867c5..d13d7cf 100644 --- a/test/mpi/rma/testlist.in +++ b/test/mpi/rma/testlist.in @@ -121,6 +121,7 @@ fence_shm 2 mpiversion=3.0 win_shared_zerobyte 4 mpiversion=3.0 win_shared_put_flush_get 4 mpiversion=3.0 get-struct 2 +at_complete 2 ## This test is not strictly correct. This was meant to test out the ## case when MPI_Test is not nonblocking. However, we ended up http://git.mpich.org/mpich.git/commitdiff/aa36f043253d93e11a1de3c8fa10410de7... commit aa36f043253d93e11a1de3c8fa10410de72e7a3d Author: Xin Zhao <[email protected]> Date: Thu Sep 25 13:21:23 2014 -0500 Fix completion on target side in Active Target synchronization. For Active Target synchronization, the original implementation does not guarantee the completion of all ops on target side when Win_wait / Win_fence returns. It is implemented using a counter, which is decremented when the last operation from that origin finishes. Win_wait / Win_fence waits until that counter reaches zero. Problem is that, when the last operation finishes, the previous GET-like operation (for example with a large data volume) may have not finished yet. This breaks the semantic of Win_wait / Win_fence. Here we fix this by increment the counter whenever we meet a GET-like operation, and decrement it when that operation finishes on target side. This will guarantee that when counter reaches zero and Win_wait / Win_fence returns, all operations are completed on the target. Signed-off-by: Pavan Balaji <[email protected]> diff --git a/src/mpid/ch3/src/ch3u_handle_recv_req.c b/src/mpid/ch3/src/ch3u_handle_recv_req.c index 4d07c94..df5583a 100644 --- a/src/mpid/ch3/src/ch3u_handle_recv_req.c +++ b/src/mpid/ch3/src/ch3u_handle_recv_req.c @@ -82,6 +82,7 @@ int MPIDI_CH3_ReqHandler_PutAccumRespComplete( MPIDI_VC_t *vc, int *complete ) { int mpi_errno = MPI_SUCCESS; + int get_acc_flag = 0; MPID_Win *win_ptr; MPIU_CHKPMEM_DECL(1); MPIDI_STATE_DECL(MPID_STATE_MPIDI_CH3_REQHANDLER_PUTACCUMRESPCOMPLETE); @@ -139,6 +140,8 @@ int MPIDI_CH3_ReqHandler_PutAccumRespComplete( MPIDI_VC_t *vc, /* Mark get portion as handled */ rreq->dev.resp_request_handle = MPI_REQUEST_NULL; + + get_acc_flag = 1; } MPID_Win_get_ptr(rreq->dev.target_win_handle, win_ptr); @@ -161,6 +164,13 @@ int MPIDI_CH3_ReqHandler_PutAccumRespComplete( MPIDI_VC_t *vc, rreq->dev.source_win_handle); if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } + if (get_acc_flag) { + /* here we decrement the Active Target counter to guarantee the GET-like + operation are completed when counter reaches zero. */ + win_ptr->my_counter--; + MPIU_Assert(win_ptr->my_counter >= 0); + } + /* mark data transfer as complete and decrement CC */ MPIDI_CH3U_Request_complete(rreq); *complete = TRUE; @@ -571,6 +581,11 @@ int MPIDI_CH3_ReqHandler_FOPComplete( MPIDI_VC_t *vc, rreq->dev.source_win_handle); if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } + /* here we decrement the Active Target counter to guarantee the GET-like + operation are completed when counter reaches zero. */ + win_ptr->my_counter--; + MPIU_Assert(win_ptr->my_counter >= 0); + *complete = 1; fn_exit: @@ -1189,6 +1204,10 @@ static int do_simple_get(MPID_Win *win_ptr, MPIDI_Win_lock_queue *lock_queue) req->kind = MPID_REQUEST_SEND; req->dev.OnDataAvail = MPIDI_CH3_ReqHandler_GetSendRespComplete; req->dev.OnFinal = MPIDI_CH3_ReqHandler_GetSendRespComplete; + + /* here we increment the Active Target counter to guarantee the GET-like + operation are completed when counter reaches zero. */ + win_ptr->my_counter++; MPIDI_Pkt_init(get_resp_pkt, MPIDI_CH3_PKT_GET_RESP); get_resp_pkt->request_handle = lock_queue->pt_single_op->request_handle; diff --git a/src/mpid/ch3/src/ch3u_handle_send_req.c b/src/mpid/ch3/src/ch3u_handle_send_req.c index 47026d5..78d740c 100644 --- a/src/mpid/ch3/src/ch3u_handle_send_req.c +++ b/src/mpid/ch3/src/ch3u_handle_send_req.c @@ -55,6 +55,11 @@ int MPIDI_CH3_ReqHandler_GetSendRespComplete( MPIDI_VC_t *vc ATTRIBUTE((unused)) mpi_errno = MPIDI_CH3_Finish_rma_op_target(NULL, win_ptr, FALSE, sreq->dev.flags, MPI_WIN_NULL); if (mpi_errno) { MPIU_ERR_POP(mpi_errno); } + /* here we decrement the Active Target counter to guarantee the GET-like + operation are completed when counter reaches zero. */ + win_ptr->my_counter--; + MPIU_Assert(win_ptr->my_counter >= 0); + /* mark data transfer as complete and decrement CC */ MPIDI_CH3U_Request_complete(sreq); *complete = TRUE; diff --git a/src/mpid/ch3/src/ch3u_rma_sync.c b/src/mpid/ch3/src/ch3u_rma_sync.c index 3944655..19e8b60 100644 --- a/src/mpid/ch3/src/ch3u_rma_sync.c +++ b/src/mpid/ch3/src/ch3u_rma_sync.c @@ -1269,7 +1269,7 @@ int MPIDI_Win_fence(int assert, MPID_Win *win_ptr) RMA ops on its window */ /* first initialize the completion counter. */ - win_ptr->my_counter = comm_size; + win_ptr->my_counter += comm_size; mpi_errno = MPIR_Reduce_scatter_block_impl(MPI_IN_PLACE, rma_target_proc, 1, MPI_INT, MPI_SUM, comm_ptr, &errflag); @@ -1286,8 +1286,8 @@ int MPIDI_Win_fence(int assert, MPID_Win *win_ptr) /* Set the completion counter */ /* FIXME: MT: this needs to be done atomically because other procs have the address and could decrement it. */ - win_ptr->my_counter = win_ptr->my_counter - comm_size + - rma_target_proc[0]; + win_ptr->my_counter -= comm_size; + win_ptr->my_counter += rma_target_proc[0]; MPIR_T_PVAR_TIMER_START(RMA, rma_winfence_issue); MPIR_T_PVAR_COUNTER_INC(RMA, rma_winfence_issue_aux, total_op_count); @@ -2292,7 +2292,7 @@ int MPIDI_Win_post(MPID_Group *post_grp_ptr, int assert, MPID_Win *win_ptr) } /* initialize the completion counter */ - win_ptr->my_counter = post_grp_size; + win_ptr->my_counter += post_grp_size; if ((assert & MPI_MODE_NOCHECK) == 0) { @@ -4600,6 +4600,10 @@ int MPIDI_CH3_PktHandler_Get( MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt, req->dev.target_win_handle = get_pkt->target_win_handle; req->dev.source_win_handle = get_pkt->source_win_handle; req->dev.flags = get_pkt->flags; + + /* here we increment the Active Target counter to guarantee the GET-like + operation are completed when counter reaches zero. */ + win_ptr->my_counter++; if (MPIR_DATATYPE_IS_PREDEFINED(get_pkt->datatype)) { @@ -4733,6 +4737,12 @@ int MPIDI_CH3_PktHandler_Accumulate( MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt, req = MPID_Request_create(); MPIU_Object_set_ref(req, 1); *rreqp = req; + + if (accum_pkt->type == MPIDI_CH3_PKT_GET_ACCUM) { + /* here we increment the Active Target counter to guarantee the GET-like + operation are completed when counter reaches zero. */ + win_ptr->my_counter++; + } req->dev.user_count = accum_pkt->count; req->dev.op = accum_pkt->op; @@ -5086,6 +5096,10 @@ int MPIDI_CH3_PktHandler_FOP( MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt, MPIU_Object_set_ref(req, 1); /* Ref is held by progress engine */ *rreqp = NULL; + /* here we increment the Active Target counter to guarantee the GET-like + operation are completed when counter reaches zero. */ + win_ptr->my_counter++; + req->dev.user_buf = NULL; /* will be set later */ req->dev.user_count = 1; req->dev.datatype = fop_pkt->datatype; @@ -5511,6 +5525,10 @@ int MPIDI_CH3_PktHandler_LockGetUnlock( MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt, req->dev.OnDataAvail = MPIDI_CH3_ReqHandler_GetSendRespComplete; req->dev.OnFinal = MPIDI_CH3_ReqHandler_GetSendRespComplete; req->kind = MPID_REQUEST_SEND; + + /* here we increment the Active Target counter to guarantee the GET-like + operation are completed when counter reaches zero. */ + win_ptr->my_counter++; MPIDI_Pkt_init(get_resp_pkt, MPIDI_CH3_PKT_GET_RESP); get_resp_pkt->request_handle = lock_get_unlock_pkt->request_handle; http://git.mpich.org/mpich.git/commitdiff/32596b62b8d4b85cca3424a85fae216843... commit 32596b62b8d4b85cca3424a85fae216843b20e06 Author: Xin Zhao <[email protected]> Date: Wed Sep 24 21:28:10 2014 -0500 Revert "Bug-fix: waiting for ACKs for Active Target Synchronization." This reverts commit 7418944673507d4fd3d3025e9e5ecfde809e9210. diff --git a/src/mpid/ch3/include/mpidpre.h b/src/mpid/ch3/include/mpidpre.h index ffb6802..76ef00f 100644 --- a/src/mpid/ch3/include/mpidpre.h +++ b/src/mpid/ch3/include/mpidpre.h @@ -302,7 +302,6 @@ struct MPIDI_Win_target_state { int start_assert; /* assert passed to MPI_Win_start */ \ int shm_allocated; /* flag: TRUE iff this window has a shared memory \ region associated with it */ \ - int ack_counter; /* counter for acknowledgement message at origin */ \ #ifdef MPIDI_CH3_WIN_DECL #define MPID_DEV_WIN_DECL \ diff --git a/src/mpid/ch3/src/ch3u_rma_sync.c b/src/mpid/ch3/src/ch3u_rma_sync.c index 918423f..3944655 100644 --- a/src/mpid/ch3/src/ch3u_rma_sync.c +++ b/src/mpid/ch3/src/ch3u_rma_sync.c @@ -1308,11 +1308,6 @@ int MPIDI_Win_fence(int assert, MPID_Win *win_ptr) if (curr_ops_cnt[curr_ptr->target_rank] == nops_to_proc[curr_ptr->target_rank] - 1) { flags = MPIDI_CH3_PKT_FLAG_RMA_AT_COMPLETE; - if (curr_ptr->type == MPIDI_RMA_PUT || - curr_ptr->type == MPIDI_RMA_ACCUMULATE) { - flags |= MPIDI_CH3_PKT_FLAG_RMA_REQ_ACK; - win_ptr->ack_counter++; - } } source_win_handle = win_ptr->handle; @@ -1385,12 +1380,11 @@ int MPIDI_Win_fence(int assert, MPID_Win *win_ptr) finish_up: /* wait for all operations from other processes to finish */ - /* waiting for acknowledgement packets from targets to arrive */ - if (win_ptr->my_counter || win_ptr->ack_counter) + if (win_ptr->my_counter) { MPIR_T_PVAR_TIMER_START(RMA, rma_winfence_wait); MPID_Progress_start(&progress_state); - while (win_ptr->my_counter || win_ptr->ack_counter) + while (win_ptr->my_counter) { mpi_errno = MPID_Progress_wait(&progress_state); /* --BEGIN ERROR HANDLING-- */ @@ -2609,7 +2603,6 @@ int MPIDI_Win_complete(MPID_Win *win_ptr) MPID_Comm *comm_ptr; MPI_Win source_win_handle, target_win_handle; int start_grp_size, *ranks_in_win_grp, rank; - MPID_Progress_state progress_state; int nRequest = 0; int nRequestNew = 0; MPIU_CHKLMEM_DECL(6); @@ -2621,6 +2614,12 @@ int MPIDI_Win_complete(MPID_Win *win_ptr) win_ptr->epoch_state != MPIDI_EPOCH_START, mpi_errno, MPI_ERR_RMA_SYNC, "**rmasync"); + /* Track access epoch state */ + if (win_ptr->epoch_state == MPIDI_EPOCH_PSCW) + win_ptr->epoch_state = MPIDI_EPOCH_POST; + else + win_ptr->epoch_state = MPIDI_EPOCH_NONE; + comm_ptr = win_ptr->comm_ptr; comm_size = comm_ptr->local_size; @@ -2701,11 +2700,6 @@ int MPIDI_Win_complete(MPID_Win *win_ptr) if (curr_ops_cnt[curr_ptr->target_rank] == nops_to_proc[curr_ptr->target_rank] - 1) { flags = MPIDI_CH3_PKT_FLAG_RMA_AT_COMPLETE; - if (curr_ptr->type == MPIDI_RMA_PUT || - curr_ptr->type == MPIDI_RMA_ACCUMULATE) { - win_ptr->ack_counter++; - flags |= MPIDI_CH3_PKT_FLAG_RMA_REQ_ACK; - } } source_win_handle = win_ptr->handle; @@ -2808,33 +2802,10 @@ int MPIDI_Win_complete(MPID_Win *win_ptr) } MPIU_Assert(MPIDI_CH3I_RMA_Ops_isempty(ops_list)); - - /* waiting for acknowledgement packets from targets to arrive */ - if (win_ptr->ack_counter) - { - MPID_Progress_start(&progress_state); - while (win_ptr->ack_counter) - { - mpi_errno = MPID_Progress_wait(&progress_state); - /* --BEGIN ERROR HANDLING-- */ - if (mpi_errno != MPI_SUCCESS) { - MPID_Progress_end(&progress_state); - MPIU_ERR_SETANDJUMP(mpi_errno,MPI_ERR_OTHER,"**winnoprogress"); - } - /* --END ERROR HANDLING-- */ - } - MPID_Progress_end(&progress_state); - } /* free the group stored in window */ MPIR_Group_release(win_ptr->start_group_ptr); win_ptr->start_group_ptr = NULL; - - /* Track access epoch state */ - if (win_ptr->epoch_state == MPIDI_EPOCH_PSCW) - win_ptr->epoch_state = MPIDI_EPOCH_POST; - else - win_ptr->epoch_state = MPIDI_EPOCH_NONE; fn_exit: MPIU_CHKLMEM_FREEALL(); @@ -5836,21 +5807,12 @@ int MPIDI_CH3_PktHandler_PtRMADone( MPIDI_VC_t *vc, MPIDI_CH3_Pkt_t *pkt, *buflen = sizeof(MPIDI_CH3_Pkt_t); MPID_Win_get_ptr(pt_rma_done_pkt->source_win_handle, win_ptr); - - if (win_ptr->epoch_state == MPIDI_EPOCH_FENCE || - win_ptr->epoch_state == MPIDI_EPOCH_PSCW || - win_ptr->epoch_state == MPIDI_EPOCH_START) { - win_ptr->ack_counter--; - MPIU_Assert(win_ptr->ack_counter >= 0); - } - else { MPIU_Assert(win_ptr->targets[pt_rma_done_pkt->target_rank].remote_lock_state != MPIDI_CH3_WIN_LOCK_NONE); if (win_ptr->targets[pt_rma_done_pkt->target_rank].remote_lock_state == MPIDI_CH3_WIN_LOCK_FLUSH) win_ptr->targets[pt_rma_done_pkt->target_rank].remote_lock_state = MPIDI_CH3_WIN_LOCK_GRANTED; else win_ptr->targets[pt_rma_done_pkt->target_rank].remote_lock_state = MPIDI_CH3_WIN_LOCK_NONE; - } *rreqp = NULL; MPIDI_CH3_Progress_signal_completion(); @@ -6175,11 +6137,6 @@ int MPIDI_CH3_Finish_rma_op_target(MPIDI_VC_t *vc, MPID_Win *win_ptr, int is_rma win_ptr->my_counter -= 1; MPIU_Assert(win_ptr->my_counter >= 0); - if (flags & MPIDI_CH3_PKT_FLAG_RMA_REQ_ACK) { - mpi_errno = MPIDI_CH3I_Send_pt_rma_done_pkt(vc, win_ptr, source_win_handle); - if (mpi_errno != MPI_SUCCESS) MPIU_ERR_POP(mpi_errno); - } - /* Signal the local process when the op counter reaches 0. */ if (win_ptr->my_counter == 0) MPIDI_CH3_Progress_signal_completion(); diff --git a/src/mpid/ch3/src/mpid_rma.c b/src/mpid/ch3/src/mpid_rma.c index 8bfe842..c112db0 100644 --- a/src/mpid/ch3/src/mpid_rma.c +++ b/src/mpid/ch3/src/mpid_rma.c @@ -299,7 +299,6 @@ static int win_init(MPI_Aint size, int disp_unit, int create_flavor, int model, (*win_ptr)->epoch_count = 0; (*win_ptr)->at_rma_ops_list = NULL; (*win_ptr)->shm_allocated = FALSE; - (*win_ptr)->ack_counter = 0; /* Initialize the passive target lock state */ MPIU_CHKPMEM_MALLOC((*win_ptr)->targets, struct MPIDI_Win_target_state *, ----------------------------------------------------------------------- Summary of changes: src/mpid/ch3/include/mpidpre.h | 1 - src/mpid/ch3/src/ch3u_handle_recv_req.c | 19 +++++ src/mpid/ch3/src/ch3u_handle_send_req.c | 5 + src/mpid/ch3/src/ch3u_rma_sync.c | 85 +++++++------------- src/mpid/ch3/src/mpid_rma.c | 1 - test/mpi/rma/Makefile.am | 3 +- test/mpi/rma/at_complete.c | 129 +++++++++++++++++++++++++++++++ test/mpi/rma/testlist.in | 1 + 8 files changed, 186 insertions(+), 58 deletions(-) create mode 100644 test/mpi/rma/at_complete.c hooks/post-receive -- MPICH primary repository