1. 03 Nov, 2014 3 commits
  2. 01 Nov, 2014 2 commits
    • Xin Zhao's avatar
      Bug-fix: avoid free NULL pointer in RMA. · 72a1e6f8
      Xin Zhao authored
      
      
      req->dev.user_buf points to the data sent from origin process
      to target process, and for FOP sometimes it points to the IMMED
      area in packet header when data can be fit in packet header.
      In such case, we should not free req->dev.user_buf in final
      request handler since that data area will be freed by the
      runtime when packet header is freed.
      
      In this patch we initialize user_buf to NULL when creating the
      request, and set it to NULL when FOP is completed, and avoid free
      a NULL pointer in final request handler.
      Signed-off-by: default avatarMin Si <msi@il.is.s.u-tokyo.ac.jp>
      72a1e6f8
    • Xin Zhao's avatar
      Bug-fix: always waiting for remote completion in Win_unlock. · c76aa786
      Xin Zhao authored and Pavan Balaji's avatar Pavan Balaji committed
      
      
      The original implementation includes an optimization which
      allows Win_unlock for exclusive lock to return without
      waiting for remote completion. This relys on the
      assumption that window memory on target process will not
      be accessed by a third party until that target process
      finishes all RMA operations and grants the lock to other
      processes. However, this assumption is not correct if user
      uses assert MPI_MODE_NOCHECK. Consider the following code:
      
                P0                              P1           P2
          MPI_Win_lock(P1, NULL, exclusive);
          MPI_Put(X);
          MPI_Win_unlock(P1, exclusive);
          MPI_Send (P2);                                MPI_Recv(P0);
                                                        MPI_Win_lock(P1, MODE_NOCHECK, exclusive);
                                                        MPI_Get(X);
                                                        MPI_Win_unlock(P1, exclusive);
      
      Both P0 and P2 issue exclusive lock to P1, and P2 uses assert
      MPI_MODE_NOCHECK because the lock should be granted to P2 after
      synchronization between P2 and P0. However, in the original
      implementation, GET operation on P2 might not get the updated
      value since Win_unlock on P0 return without waiting for remote
      completion.
      
      In this patch we delete this optimization. In Win_free, since every
      Win_unlock guarantees the remote completion, target process no
      longer needs to do additional counting works to detect target-side
      completion, but only needs to do a global barrier.
      Signed-off-by: Pavan Balaji's avatarPavan Balaji <balaji@anl.gov>
      c76aa786
  3. 01 Oct, 2014 3 commits
  4. 28 Sep, 2014 1 commit
    • Xin Zhao's avatar
      Fix completion on target side in Active Target synchronization. · aa36f043
      Xin Zhao authored
      
      
      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's avatarPavan Balaji <balaji@anl.gov>
      aa36f043
  5. 18 Jul, 2014 1 commit
  6. 17 Jul, 2014 1 commit
    • Pavan Balaji's avatar
      Simplified RMA_Op structure. · 274a5a70
      Pavan Balaji authored
      
      
      We were creating duplicating information in the operation structure
      and in the packet structure when the message is actually issued.
      Since most of the information is the same anyway, this patch just
      embeds a packet structure into the operation structure.
      Signed-off-by: default avatarXin Zhao <xinzhao3@illinois.edu>
      274a5a70
  7. 22 May, 2014 1 commit
    • Wesley Bland's avatar
      Make handling of request cleanup more uniform · 1e171ff6
      Wesley Bland authored
      
      
      There are quite a few places where the request cleanup is done via:
      
      MPIU_Object_set_ref(req, 0);
      MPIDI_CH3_Request_destroy(req);
      
      when it should be:
      
      MPID_Request_release(req);
      
      This makes the handling more uniform so requests are cleaned up by releasing
      references rather than hitting them with the destroy hammer.
      
      Fixes #1664
      Signed-off-by: Kenneth Raffenetti's avatarKen Raffenetti <raffenet@mcs.anl.gov>
      1e171ff6
  8. 30 Dec, 2013 1 commit
  9. 31 Oct, 2013 1 commit
  10. 26 Sep, 2013 1 commit
  11. 28 Jul, 2013 1 commit
  12. 21 Feb, 2013 4 commits
    • James Dinan's avatar
      Removed unused single_op_opt field from MPID_Request · 255fb4a6
      James Dinan authored
      The single_op_opt flag in the request object was previously used to
      track whether an operation is a lock-op-unlock type, for the purposes of
      completion.  Tracking this state has been merged into the packet header
      flags, so the single_op_opt flag is no longer needed.
      
      Reviewer: goodell
      255fb4a6
    • James Dinan's avatar
      RMA sync. piggybacking from origin->target · 4e67607f
      James Dinan authored
      This patch uses packet header flags to piggyback the unlock operation on other
      RMA operations.  For most operations, there is no net change.  However, FOP and
      GACC, unlock piggybacking was previously not implemented.
      
      Reviewer: goodell
      4e67607f
    • James Dinan's avatar
      Consolidated RMA op finalization code · bba35589
      James Dinan authored
      This patch consolidates the synchronization and tracking of RMA operations into
      a single routine that is called whenever we complete an operation.  The only
      exception are lock-op-unlock operations that are completed from within the lock
      operation processing code.
      
      This code is pretty ugly, but it will get cleaner once packet flags are been
      added.
      
      Reviewer: goodell
      bba35589
    • James Dinan's avatar
      Temporarily reverted is_gacc_op bugfix · c5312557
      James Dinan authored
      Partially reverted [0b364068] in preparation for incorporating new
      piggybacking infrastructure.  This temporarily re-introduces that bug
      and it will be fixed again with the new piggybacking patch.
      
      Reviwer: goodell
      c5312557
  13. 05 Feb, 2013 1 commit
    • James Dinan's avatar
      BUGFIX: Unlock piggybacking for Get_accumulate · 0b364068
      James Dinan authored
      GACC operations were both piggybacking the unlock message to the origin, and
      sending back a PT done packet.  This was causing the origin to be unlocked
      twice.  When another lock operation was performed between the GACC and PT done
      unlock operations, there was a synchronization race.
      0b364068
  14. 24 Jan, 2013 1 commit
  15. 05 Nov, 2012 2 commits
  16. 11 Oct, 2012 1 commit
  17. 10 Oct, 2012 1 commit
  18. 20 Sep, 2012 1 commit
    • James Dinan's avatar
      [svn-r10249] Updated fetch_and_op implementation · 9574b9ab
      James Dinan authored
      Updated the fetch_and_op implementation to have two data transfer paths; one
      where data can be embedded in the packet header and one where it is sent
      separately.  With this change, the header size is back to 40 bytes.
      
      Reviewer: buntinas
      9574b9ab
  19. 23 Aug, 2012 1 commit
  20. 06 Apr, 2012 1 commit
  21. 04 Nov, 2011 1 commit
  22. 06 Nov, 2010 1 commit
    • William Gropp's avatar
      [svn-r7416] Major improvement to RMA performance for long lists of operations,... · 3608ca24
      William Gropp authored
      [svn-r7416] Major improvement to RMA performance for long lists of operations, an immediate mode accumulate for single ints, store the MPID_Comm within the window, and added a basic performance instrumentation interface that was extensively used to improve the RMA performance (enabled with --enable-g=instr).  With these fixes, MPICH2 can run the one-sided version of the Graph500 benchmark at a respectable if not great rate
      3608ca24
  23. 06 Oct, 2010 1 commit
  24. 08 Sep, 2010 1 commit
  25. 29 Jul, 2010 1 commit
  26. 24 Sep, 2009 1 commit
    • William Gropp's avatar
      [svn-r5368] Use the correct type in the segment calls - it must be an... · efb35431
      William Gropp authored
      [svn-r5368] Use the correct type in the segment calls - it must be an MPI_Aint, not an MPIDI_msg_sz_t, particularly when the size of MPI_Aint is changed to match MPI_Offset (the segment calls specify an MPI_Aint at the last argument, for example.  This is part of the changes needed to make attributes work properly when --with-aint-size=8 is selected
      efb35431
  27. 24 Jul, 2009 1 commit
  28. 13 Mar, 2009 1 commit
    • Jayesh Krishna's avatar
      [svn-r4062] 1) Modifying the datatype code to find the number of contig blocks... · ac4f4cd1
      Jayesh Krishna authored
      [svn-r4062] 1) Modifying the datatype code to find the number of contig blocks in an instance of an MPI derived datatype - Since finding the real number of contig blocks is not easy we find a reasonable upper bound instead. This also fixes the case where the number of contig blocks was uninitialized for contiguous datatypes. Refer ticket #428 for details (2) Adding a test case, test1_dt.c, to test the fix - Review @ rross, thakur
      ac4f4cd1
  29. 12 Mar, 2009 1 commit
  30. 31 Dec, 2008 1 commit
  31. 09 Oct, 2008 1 commit