[mpich-commits] [mpich] MPICH primary repository branch, master, updated. v3.0.2-9-g3593b5c

mysql vizuser noreply at mpich.org
Wed Feb 6 10:03:23 CST 2013


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  3593b5c0130a485bfc0da8c383146c6f46e50f70 (commit)
       via  460cf5ca35bba3ec72979e7d2a3c189bd4a45853 (commit)
       via  fbd9559322c9918e3973151df222c3d6d4261f10 (commit)
      from  2bdb181f2ff8607c3cfa6f7d306e94f604dc94ba (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/3593b5c0130a485bfc0da8c383146c6f46e50f70

commit 3593b5c0130a485bfc0da8c383146c6f46e50f70
Author: James Dinan <dinan at mcs.anl.gov>
Date:   Wed Feb 6 09:50:21 2013 -0600

    PERF: Overlap req/wait for lock-all on shr men win
    
    Send out all lock requests before waiting for lock acquisition.  This
    should improve the performance of lock-all operations on shared memory
    windows.
    
    Reviewer: goodell

diff --git a/src/mpid/ch3/src/ch3u_rma_sync.c b/src/mpid/ch3/src/ch3u_rma_sync.c
index 908064e..4a5ef1b 100644
--- a/src/mpid/ch3/src/ch3u_rma_sync.c
+++ b/src/mpid/ch3/src/ch3u_rma_sync.c
@@ -2376,11 +2376,15 @@ int MPIDI_Win_lock_all(int assert, MPID_Win *win_ptr)
 
             mpi_errno = MPIDI_CH3I_Send_lock_msg(i, MPI_LOCK_SHARED, win_ptr);
             if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
+        }
+
+        for (i = 0; i < MPIR_Comm_size(win_ptr->comm_ptr); i++) {
+            /* Local process is already locked */
+            if (i == win_ptr->myrank) continue;
 
             mpi_errno = MPIDI_CH3I_Wait_for_lock_granted(win_ptr, i);
             if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
         }
-
     }
 
 fn_exit:

http://git.mpich.org/mpich.git/commitdiff/460cf5ca35bba3ec72979e7d2a3c189bd4a45853

commit 460cf5ca35bba3ec72979e7d2a3c189bd4a45853
Author: James Dinan <dinan at mcs.anl.gov>
Date:   Tue Feb 5 10:01:42 2013 -0600

    PERF: Flush should ignore inactive targets
    
    This fix enables flush to ignore non-local targets that have not been targeted
    by an RMA operation.  Prior to this fix, a call to flush-all would result in
    acquiring the lock at all targets, which is extremely inefficient.
    
    Reviewer: goodell

diff --git a/src/mpid/ch3/src/ch3u_rma_sync.c b/src/mpid/ch3/src/ch3u_rma_sync.c
index 126c91f..908064e 100644
--- a/src/mpid/ch3/src/ch3u_rma_sync.c
+++ b/src/mpid/ch3/src/ch3u_rma_sync.c
@@ -2136,6 +2136,7 @@ int MPIDI_Win_flush(int rank, MPID_Win *win_ptr)
 {
     int mpi_errno = MPI_SUCCESS;
     int wait_for_rma_done_pkt = 0;
+    MPIDI_RMA_Op_t *rma_op;
     MPIDI_STATE_DECL(MPID_STATE_MPIDI_WIN_FLUSH);
 
     MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_WIN_FLUSH);
@@ -2174,6 +2175,16 @@ int MPIDI_Win_flush(int rank, MPID_Win *win_ptr)
         goto fn_exit;
     }
 
+    rma_op = MPIDI_CH3I_RMA_Ops_head(&win_ptr->targets[rank].rma_ops_list);
+
+    /* If there is no activity at this target (e.g. lock-all was called, but we
+     * haven't communicated with this target), don't do anything. */
+    if (win_ptr->targets[rank].remote_lock_state == MPIDI_CH3_WIN_LOCK_CALLED
+        && rma_op == NULL)
+    {
+        goto fn_exit;
+    }
+
     /* MT: If another thread is performing a flush, wait for them to finish. */
     if (win_ptr->targets[rank].remote_lock_state == MPIDI_CH3_WIN_LOCK_FLUSH)
     {

http://git.mpich.org/mpich.git/commitdiff/fbd9559322c9918e3973151df222c3d6d4261f10

commit fbd9559322c9918e3973151df222c3d6d4261f10
Author: James Dinan <dinan at mcs.anl.gov>
Date:   Thu Nov 15 11:10:48 2012 -0600

    Eliminate enqueueing of lock op in RMA ops list
    
    Prior to this patch, a lock entry was enqueued in the RMA ops list when
    Win_lock was called.  This patch adds a new state tracking mechanism, which we
    use to record the synchronization state with respect to each RMA target.  This
    new mechanism absorbs tracking of lock operation and the lock state at the
    target.  It significantly simplifies the RMA synchronization and ops list
    processing.
    
    Reviewer: goodell

diff --git a/src/mpid/ch3/include/mpidpre.h b/src/mpid/ch3/include/mpidpre.h
index 366bf1f..de73708 100644
--- a/src/mpid/ch3/include/mpidpre.h
+++ b/src/mpid/ch3/include/mpidpre.h
@@ -202,6 +202,7 @@ typedef struct MPIDI_VC * MPID_VCR;
 
 enum MPIDI_CH3_Lock_states {
     MPIDI_CH3_WIN_LOCK_NONE = 0,
+    MPIDI_CH3_WIN_LOCK_CALLED,
     MPIDI_CH3_WIN_LOCK_REQUESTED,
     MPIDI_CH3_WIN_LOCK_GRANTED,
     MPIDI_CH3_WIN_LOCK_FLUSH
@@ -250,6 +251,8 @@ struct MPIDI_Win_target_state {
                                    (shared/exclusive) of the target
                                    process for passive target RMA. Valid
                                    whenever state != NONE. */
+    int remote_lock_assert;     /* Assertion value provided in the call
+                                   to Lock */
 };
 
 #define MPIDI_DEV_WIN_DECL                                               \
diff --git a/src/mpid/ch3/include/mpidrma.h b/src/mpid/ch3/include/mpidrma.h
index f0f7fa1..ad8789d 100644
--- a/src/mpid/ch3/include/mpidrma.h
+++ b/src/mpid/ch3/include/mpidrma.h
@@ -12,7 +12,7 @@ typedef enum MPIDI_RMA_Op_type {
     MPIDI_RMA_PUT               = 23,
     MPIDI_RMA_GET               = 24,
     MPIDI_RMA_ACCUMULATE        = 25,
-    MPIDI_RMA_LOCK              = 26,
+ /* REMOVED: MPIDI_RMA_LOCK     = 26, */
     MPIDI_RMA_ACC_CONTIG        = 27,
     MPIDI_RMA_GET_ACCUMULATE    = 28,
     MPIDI_RMA_COMPARE_AND_SWAP  = 29,
@@ -70,7 +70,6 @@ typedef struct MPIDI_RMA_Op {
     int target_count;
     MPI_Datatype target_datatype;
     MPI_Op op;  /* for accumulate */
-    int lock_type;  /* for win_lock */
     /* Used to complete operations */
     struct MPID_Request *request;
     MPIDI_RMA_dtype_info dtype_info;
diff --git a/src/mpid/ch3/src/ch3u_rma_sync.c b/src/mpid/ch3/src/ch3u_rma_sync.c
index 6ce857a..126c91f 100644
--- a/src/mpid/ch3/src/ch3u_rma_sync.c
+++ b/src/mpid/ch3/src/ch3u_rma_sync.c
@@ -1849,7 +1849,7 @@ int MPIDI_Win_test(MPID_Win *win_ptr, int *flag)
 int MPIDI_Win_lock(int lock_type, int dest, int assert, MPID_Win *win_ptr)
 {
     int mpi_errno = MPI_SUCCESS;
-    MPIDI_RMA_Op_t *rma_op = NULL;
+    struct MPIDI_Win_target_state *target_state;
     MPIDI_STATE_DECL(MPID_STATE_MPIDI_WIN_LOCK);
 
     MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_WIN_LOCK);
@@ -1868,14 +1868,11 @@ int MPIDI_Win_lock(int lock_type, int dest, int assert, MPID_Win *win_ptr)
                         win_ptr->epoch_state != MPIDI_EPOCH_LOCK,
                         mpi_errno, MPI_ERR_RMA_SYNC, "**rmasync");
 
-#ifdef HAVE_ERROR_CHECKING
-    rma_op = MPIDI_CH3I_RMA_Ops_head(&win_ptr->targets[dest].rma_ops_list);
+    target_state = &win_ptr->targets[dest];
 
-    /* Check if a lock has already been issued (in the ops list or already issued) */
-    MPIU_ERR_CHKANDJUMP((rma_op != NULL && rma_op->type == MPIDI_RMA_LOCK) ||
-                        win_ptr->targets[dest].remote_lock_state != MPIDI_CH3_WIN_LOCK_NONE,
+    /* Check if a lock has already been issued */
+    MPIU_ERR_CHKANDJUMP(target_state->remote_lock_state != MPIDI_CH3_WIN_LOCK_NONE,
                         mpi_errno, MPI_ERR_RMA_SYNC, "**rmasync");
-#endif /* HAVE_ERROR_CHECKING */
 
     /* Track access epoch state */
     if (win_ptr->epoch_state != MPIDI_EPOCH_LOCK_ALL) {
@@ -1883,6 +1880,10 @@ int MPIDI_Win_lock(int lock_type, int dest, int assert, MPID_Win *win_ptr)
         win_ptr->epoch_state = MPIDI_EPOCH_LOCK;
     }
 
+    target_state->remote_lock_state  = MPIDI_CH3_WIN_LOCK_CALLED;
+    target_state->remote_lock_mode   = lock_type;
+    target_state->remote_lock_assert = assert;
+
     if (dest == win_ptr->myrank) {
         /* The target is this process itself. We must block until the lock
          * is acquired.  Once it is acquired, local puts, gets, accumulates
@@ -1903,28 +1904,11 @@ int MPIDI_Win_lock(int lock_type, int dest, int assert, MPID_Win *win_ptr)
         mpi_errno = MPIDI_CH3I_Wait_for_lock_granted(win_ptr, dest);
         if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
     }
-    else {
+    else if (MPIR_PARAM_RMA_LOCK_IMMED) {
         /* TODO: Make this mode of operation available through an assert
            argument or info key. */
-        if (MPIR_PARAM_RMA_LOCK_IMMED) {
-            mpi_errno = MPIDI_CH3I_Send_lock_msg(dest, lock_type, win_ptr);
-            MPIU_ERR_CHKANDJUMP(mpi_errno != MPI_SUCCESS, mpi_errno, MPI_ERR_OTHER, "**winRMAmessage");
-        }
-        else {
-            MPIDI_RMA_Op_t *new_ptr = NULL;
-
-            /* target is some other process. add the lock request to rma_ops_list */
-            MPIU_INSTR_DURATION_START(rmaqueue_alloc);
-            mpi_errno = MPIDI_CH3I_RMA_Ops_alloc_tail(&win_ptr->targets[dest].rma_ops_list, &new_ptr);
-            MPIU_INSTR_DURATION_END(rmaqueue_alloc);
-            if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
-
-            MPIU_INSTR_DURATION_START(rmaqueue_set);
-            new_ptr->type = MPIDI_RMA_LOCK;
-            new_ptr->target_rank = dest;
-            new_ptr->lock_type = lock_type;
-            MPIU_INSTR_DURATION_END(rmaqueue_set);
-        }
+        mpi_errno = MPIDI_CH3I_Send_lock_msg(dest, lock_type, win_ptr);
+        MPIU_ERR_CHKANDJUMP(mpi_errno != MPI_SUCCESS, mpi_errno, MPI_ERR_OTHER, "**winRMAmessage");
     }
 
  fn_exit:
@@ -1943,20 +1927,21 @@ int MPIDI_Win_lock(int lock_type, int dest, int assert, MPID_Win *win_ptr)
 int MPIDI_Win_unlock(int dest, MPID_Win *win_ptr)
 {
     int mpi_errno=MPI_SUCCESS;
-    int single_op_opt, type_size;
-    MPIDI_RMA_Op_t *rma_op, *curr_op;
-    MPID_Comm *comm_ptr;
-    MPIDI_VC_t * vc;
-    int wait_for_rma_done_pkt = 0, predefined;
+    int single_op_opt = 0;
+    MPIDI_RMA_Op_t *rma_op;
+    int wait_for_rma_done_pkt = 0;
     MPIDI_STATE_DECL(MPID_STATE_MPIDI_WIN_UNLOCK);
     MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_WIN_UNLOCK);
 
     if (dest == MPI_PROC_NULL) goto fn_exit;
-        
+
     MPIU_ERR_CHKANDJUMP(win_ptr->epoch_state != MPIDI_EPOCH_LOCK &&
                         win_ptr->epoch_state != MPIDI_EPOCH_LOCK_ALL,
                         mpi_errno, MPI_ERR_RMA_SYNC, "**rmasync");
 
+    MPIU_ERR_CHKANDJUMP(win_ptr->targets[dest].remote_lock_state == MPIDI_CH3_WIN_LOCK_NONE,
+                        mpi_errno, MPI_ERR_RMA_SYNC, "**rmasync");
+
     /* Track access epoch state */
     if (win_ptr->epoch_state == MPIDI_EPOCH_LOCK) {
         win_ptr->epoch_count--;
@@ -1984,54 +1969,39 @@ int MPIDI_Win_unlock(int dest, MPID_Win *win_ptr)
 	goto fn_exit;
     }
         
-    comm_ptr = win_ptr->comm_ptr;
-        
     rma_op = MPIDI_CH3I_RMA_Ops_head(&win_ptr->targets[dest].rma_ops_list);
-    
-    /* win_lock was not called. return error */
-    if ( win_ptr->targets[dest].remote_lock_state == MPIDI_CH3_WIN_LOCK_NONE &&
-         ( rma_op == NULL || rma_op->type != MPIDI_RMA_LOCK ) &&
-         win_ptr->epoch_state != MPIDI_EPOCH_LOCK_ALL )
+
+    /* Lock was called, but the lock was not requested and there are no ops to
+     * perform.  Do nothing and return. */
+    if (rma_op == NULL &&
+        win_ptr->targets[dest].remote_lock_state == MPIDI_CH3_WIN_LOCK_CALLED)
     {
-	MPIU_ERR_SETANDJUMP(mpi_errno, MPI_ERR_RMA_SYNC, "**rmasync");
-    }
-        
-    if (rma_op && rma_op->target_rank != dest) {
-	/* The target rank is different from the one passed to win_lock! */
-	MPIU_ERR_SETANDJUMP2(mpi_errno,MPI_ERR_OTHER,"**winunlockrank", 
-		     "**winunlockrank %d %d", dest, rma_op->target_rank);
+        win_ptr->targets[dest].remote_lock_state = MPIDI_CH3_WIN_LOCK_NONE;
+        goto fn_exit;
     }
 
-    /* Only win_lock+unlock called, no put/get/acc. If we haven't requested the
-       lock, we can do nothing and return. */
-    if (rma_op && rma_op->type == MPIDI_RMA_LOCK && rma_op->next == NULL &&
-        win_ptr->targets[dest].remote_lock_state == MPIDI_CH3_WIN_LOCK_NONE) {
-        MPIDI_CH3I_RMA_Ops_free(&win_ptr->targets[dest].rma_ops_list);
-	goto fn_exit;
-    }
-        
-    single_op_opt = 0;
-
-    MPIDI_Comm_get_vc_set_active(comm_ptr, dest, &vc);
-
     /* TODO: MPI-3: Add lock->cas/fop/gacc->unlock optimization.  */
     /* TODO: MPI-3: Add lock_all->op optimization. */
     /* LOCK-OP-UNLOCK Optimization -- This optimization can't be used if we
        have already requested the lock. */
     if ( MPIR_PARAM_RMA_MERGE_LOCK_OP_UNLOCK &&
-         rma_op && rma_op->type == MPIDI_RMA_LOCK &&
-         rma_op->next->next == NULL &&
-         rma_op->next->type != MPIDI_RMA_COMPARE_AND_SWAP &&
-         rma_op->next->type != MPIDI_RMA_FETCH_AND_OP &&
-         rma_op->next->type != MPIDI_RMA_GET_ACCUMULATE ) {
+         win_ptr->targets[dest].remote_lock_state == MPIDI_CH3_WIN_LOCK_CALLED &&
+         rma_op && rma_op->next == NULL /* There is only one op */ &&
+         rma_op->type != MPIDI_RMA_COMPARE_AND_SWAP &&
+         rma_op->type != MPIDI_RMA_FETCH_AND_OP &&
+         rma_op->type != MPIDI_RMA_GET_ACCUMULATE )
+    {
 	/* Single put, get, or accumulate between the lock and unlock. If it
 	 * is of small size and predefined datatype at the target, we
 	 * do an optimization where the lock and the RMA operation are
 	 * sent in a single packet. Otherwise, we send a separate lock
 	 * request first. */
+        int type_size, predefined;
+        MPIDI_VC_t *vc;
+        MPIDI_RMA_Op_t *curr_op = rma_op;
+
+        MPIDI_Comm_get_vc_set_active(win_ptr->comm_ptr, dest, &vc);
 
-	curr_op = rma_op->next;
-	
 	MPID_Datatype_get_size_macro(curr_op->origin_datatype, type_size);
 	
 	MPIDI_CH3I_DATATYPE_IS_PREDEFINED(curr_op->target_datatype, predefined);
@@ -2059,15 +2029,8 @@ int MPIDI_Win_unlock(int dest, MPID_Win *win_ptr)
         /* Send a lock packet over to the target. wait for the lock_granted
            reply. Then do all the RMA ops. */
 
-        if (win_ptr->targets[dest].remote_lock_state == MPIDI_CH3_WIN_LOCK_NONE) {
-            int lock_type;
-
-            if (win_ptr->epoch_state == MPIDI_EPOCH_LOCK_ALL)
-                lock_type = MPI_LOCK_SHARED;
-            else
-                lock_type = rma_op->lock_type;
-
-            mpi_errno = MPIDI_CH3I_Send_lock_msg(dest, lock_type, win_ptr);
+        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, win_ptr);
             if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
         }
 
@@ -2112,8 +2075,9 @@ int MPIDI_Win_unlock(int dest, MPID_Win *win_ptr)
         win_ptr->targets[dest].remote_lock_state = MPIDI_CH3_WIN_LOCK_NONE;
     }
     
- fn_exit:
     MPIU_Assert(MPIDI_CH3I_RMA_Ops_isempty(&win_ptr->targets[dest].rma_ops_list));
+
+ fn_exit:
     MPIDI_RMA_FUNC_EXIT(MPID_STATE_MPIDI_WIN_UNLOCK);
     return mpi_errno;
     /* --BEGIN ERROR HANDLING-- */
@@ -2180,6 +2144,10 @@ int MPIDI_Win_flush(int rank, MPID_Win *win_ptr)
                         win_ptr->epoch_state != MPIDI_EPOCH_LOCK_ALL,
                         mpi_errno, MPI_ERR_RMA_SYNC, "**rmasync");
 
+    /* Check if win_lock was called */
+    MPIU_ERR_CHKANDJUMP(win_ptr->targets[rank].remote_lock_state == MPIDI_CH3_WIN_LOCK_NONE,
+                        mpi_errno, MPI_ERR_RMA_SYNC, "**rmasync");
+
     /* Local flush: ops are performed immediately on the local process */
     if (rank == win_ptr->comm_ptr->rank) {
         MPIU_Assert(win_ptr->targets[rank].remote_lock_state == MPIDI_CH3_WIN_LOCK_GRANTED);
@@ -2228,23 +2196,8 @@ int MPIDI_Win_flush(int rank, MPID_Win *win_ptr)
     /* Send a lock packet over to the target, wait for the lock_granted
        reply, and perform the RMA ops. */
 
-    if (win_ptr->targets[rank].remote_lock_state == MPIDI_CH3_WIN_LOCK_NONE) {
-        int lock_type;
-        if (win_ptr->epoch_state == MPIDI_EPOCH_LOCK_ALL) {
-            lock_type = MPI_LOCK_SHARED;
-        }
-        else {
-            MPIDI_RMA_Op_t *head = MPIDI_CH3I_RMA_Ops_head(&win_ptr->targets[rank].rma_ops_list);
-
-            /* Ensure that win_lock is waiting at the head of the ops list */
-            MPIU_ERR_CHKANDJUMP(MPIDI_CH3I_RMA_Ops_isempty(&win_ptr->targets[rank].rma_ops_list) ||
-                                head->type != MPIDI_RMA_LOCK || head->target_rank != rank,
-                                mpi_errno, MPI_ERR_RMA_SYNC, "**rmasync");
-
-            lock_type = head->lock_type;
-        }
-
-        mpi_errno = MPIDI_CH3I_Send_lock_msg(rank, lock_type, win_ptr);
+    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);
         if (mpi_errno) { MPIU_ERR_POP(mpi_errno); }
     }
 
@@ -2386,6 +2339,16 @@ int MPIDI_Win_lock_all(int assert, MPID_Win *win_ptr)
     /* Track access epoch state */
     win_ptr->epoch_state = MPIDI_EPOCH_LOCK_ALL;
 
+    /* Set the target's lock state to "called" for all targets */
+    /* FIXME: Don't use this O(p) approach */
+    for (i = 0; i < MPIR_Comm_size(win_ptr->comm_ptr); i++) {
+        MPIU_Assert(win_ptr->targets[i].remote_lock_state == MPIDI_CH3_WIN_LOCK_NONE);
+
+        win_ptr->targets[i].remote_lock_state  = MPIDI_CH3_WIN_LOCK_CALLED;
+        win_ptr->targets[i].remote_lock_mode   = MPI_LOCK_SHARED;
+        win_ptr->targets[i].remote_lock_assert = assert;
+    }
+
     /* Immediately lock the local process for load/store access */
     mpi_errno = MPIDI_CH3I_Acquire_local_lock(win_ptr, MPI_LOCK_SHARED);
     if (mpi_errno != MPI_SUCCESS) { MPIU_ERR_POP(mpi_errno); }
@@ -2530,19 +2493,12 @@ static int MPIDI_CH3I_Do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
             *wait_for_rma_done_pkt = 0;
         }
         else {
-            MPIDI_RMA_Op_t *head = MPIDI_CH3I_RMA_Ops_head(&win_ptr->targets[target_rank].rma_ops_list);
-
             /* go through the list and move the first get operation 
                (if there is one) to the end.  Note that the first
 	       operation may be a lock, so we can skip it */
             
-            if (head->type == MPIDI_RMA_LOCK) {
-                curr_ptr = head->next;
-            } else {
-                curr_ptr = head;
-            }
-            
             *wait_for_rma_done_pkt = 1;
+            curr_ptr = MPIDI_CH3I_RMA_Ops_head(&win_ptr->targets[target_rank].rma_ops_list);
             
             while (curr_ptr != NULL) {
                 if (curr_ptr->type == MPIDI_RMA_GET) {
@@ -2562,13 +2518,6 @@ static int MPIDI_CH3I_Do_passive_target_rma(MPID_Win *win_ptr, int target_rank,
 
     curr_ptr = MPIDI_CH3I_RMA_Ops_head(&win_ptr->targets[target_rank].rma_ops_list);
 
-    /* Remove the lock operation if it's still on the head of the list */
-    if (!MPIDI_CH3I_RMA_Ops_isempty(&win_ptr->targets[target_rank].rma_ops_list) &&
-        MPIDI_CH3I_RMA_Ops_head(&win_ptr->targets[target_rank].rma_ops_list)->type == MPIDI_RMA_LOCK)
-    {
-        MPIDI_CH3I_RMA_Ops_free_and_next(&win_ptr->targets[target_rank].rma_ops_list, &curr_ptr);
-    }
-
     nops = 0;
     while (curr_ptr != NULL) {
         nops++;
@@ -2667,7 +2616,7 @@ static int MPIDI_CH3I_Send_lock_msg(int dest, int lock_type, MPID_Win *win_ptr)
     MPIDI_STATE_DECL(MPID_STATE_MPIDI_SEND_LOCK_MSG);
     MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_SEND_LOCK_MSG);
 
-    MPIU_Assert(win_ptr->targets[dest].remote_lock_state == MPIDI_CH3_WIN_LOCK_NONE);
+    MPIU_Assert(win_ptr->targets[dest].remote_lock_state == MPIDI_CH3_WIN_LOCK_CALLED);
 
     MPIDI_Comm_get_vc_set_active(win_ptr->comm_ptr, dest, &vc);
 
@@ -2756,6 +2705,9 @@ static int MPIDI_CH3I_Wait_for_lock_granted(MPID_Win *win_ptr, int target_rank)
      * packet sets the remote_lock_state flag to GRANTED.
      */
 
+    MPIU_Assert(win_ptr->targets[target_rank].remote_lock_state == MPIDI_CH3_WIN_LOCK_REQUESTED ||
+                win_ptr->targets[target_rank].remote_lock_state == MPIDI_CH3_WIN_LOCK_GRANTED);
+
     /* poke the progress engine until remote_lock_state flag is set to GRANTED */
     if (win_ptr->targets[target_rank].remote_lock_state != MPIDI_CH3_WIN_LOCK_GRANTED) {
         MPID_Progress_state progress_state;
@@ -2896,9 +2848,9 @@ static int MPIDI_CH3I_Send_lock_put_or_acc(MPID_Win *win_ptr, int target_rank)
 
     MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_SEND_LOCK_PUT_OR_ACC);
 
-    lock_type = MPIDI_CH3I_RMA_Ops_head(&win_ptr->targets[target_rank].rma_ops_list)->lock_type;
+    lock_type = win_ptr->targets[target_rank].remote_lock_mode;
 
-    rma_op = MPIDI_CH3I_RMA_Ops_head(&win_ptr->targets[target_rank].rma_ops_list)->next;
+    rma_op = MPIDI_CH3I_RMA_Ops_head(&win_ptr->targets[target_rank].rma_ops_list);
 
     win_ptr->pt_rma_puts_accs[rma_op->target_rank]++;
 
@@ -3093,9 +3045,9 @@ static int MPIDI_CH3I_Send_lock_get(MPID_Win *win_ptr, int target_rank)
 
     MPIDI_RMA_FUNC_ENTER(MPID_STATE_MPIDI_CH3I_SEND_LOCK_GET);
 
-    lock_type = MPIDI_CH3I_RMA_Ops_head(&win_ptr->targets[target_rank].rma_ops_list)->lock_type;
+    lock_type = win_ptr->targets[target_rank].remote_lock_mode;
 
-    rma_op = MPIDI_CH3I_RMA_Ops_head(&win_ptr->targets[target_rank].rma_ops_list)->next;
+    rma_op = MPIDI_CH3I_RMA_Ops_head(&win_ptr->targets[target_rank].rma_ops_list);
 
     /* create a request, store the origin buf, cnt, datatype in it,
        and pass a handle to it in the get packet. When the get

-----------------------------------------------------------------------

Summary of changes:
 src/mpid/ch3/include/mpidpre.h   |    3 +
 src/mpid/ch3/include/mpidrma.h   |    3 +-
 src/mpid/ch3/src/ch3u_rma_sync.c |  195 ++++++++++++++++----------------------
 3 files changed, 85 insertions(+), 116 deletions(-)


hooks/post-receive
-- 
MPICH primary repository


More information about the commits mailing list