Xin Zhao authored Nov 02, 2014 and Pavan Balaji committed Nov 03, 2014

Split RMA functionality into smaller files, and move functions
to where they belong based on the file names.

Signed-off-by: Pavan Balaji <balaji@anl.gov>

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: Min Si <msi@il.is.s.u-tokyo.ac.jp>

Xin Zhao authored Aug 12, 2014 and Pavan Balaji committed Nov 01, 2014

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 <balaji@anl.gov>

at_completion_counter is used to indicate if all Active Target
operations have completed on this target.

Signed-off-by: Pavan Balaji <balaji@anl.gov>

For GET-like operations, We should increment the Active Target counter
when the process of sending back data is not completed immediately on
target and a response request is created. We should decrement the counter
when the process of sending back data is completed on target side.

Signed-off-by: Pavan Balaji <balaji@anl.gov>

In the original implementation, for GACC/FOP/CAS, the function
MPIDI_CH3_Finish_rma_op_target (includes operations that should
be performed on target when that operation finishes on target)
is not called when that operation real finishes, but is called
after starting send back data.

Here we fix it to make the function called after sending process
on target is completed.

Signed-off-by: Pavan Balaji <balaji@anl.gov>

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 <balaji@anl.gov>

This reverts commit 274a5a70.

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: Xin Zhao <xinzhao3@illinois.edu>

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: Ken Raffenetti <raffenet@mcs.anl.gov>

Mark those variables exclusively being used for assertions as potentially
unused to avoid compiler warnings when the assertion macro does nothing. These
show up with --enable-fast.

Signed-off-by: Pavan Balaji <balaji@mcs.anl.gov>

Dave Goodell authored Apr 04, 2013 and Rob Latham committed Oct 31, 2013

Also includes random fixes to `-Wshorten-64-to-32` warnings which might
need to be teased out.

Signed-off-by: Pavan Balaji <balaji@mcs.anl.gov>

The check was originally in the ch3 layer, but doesn't seem to use any
ch3 specific information.  This macro will be useful at the upper
layers for optimizations, e.g., in the localcopy routine.

Signed-off-by: Xin Zhao <xinzhao3@illinois.edu>

Xin Zhao authored Jul 22, 2013 and Pavan Balaji committed Jul 28, 2013

If "alloc_shm" is set, it may happen that the target process is doing a RMA operation
from a remote process concurrently with a local process is also doing a RMA operation
on the same target and on overlapping memory location.

Signed-off-by: Pavan Balaji <balaji@mcs.anl.gov>

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

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

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

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

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.

Fetch-and-op has been updated to ignore the origin data and perform no
operation when the given op is MPI_NO_OP.

Reviewer: goodell

Reviewer: buntinas

Reviewer: goodell

By setting "indent-tabs-mode:nil" we should hopefully begin to slowly
squeeze out hard tabs from the source without a disruptive (to
downstream projects) whitespace-fixing change.

No reviewer.

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

Pulled bit manipulation arithmetic into macros for converting handles to
indices in MPIR_Op and MPIR_Op_check_dtype function pointer tables.

Reviewer: buntinas

No reviewer.

[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

[svn-r7312] Correct use of MPI_ERR_NO_MEM (should be MPI_ERR_OTHER) for out-of-memory that does not pertain to MPI_Alloc_mem and add detail to error messages about out-of-memory

[svn-r7186] Fixes to allow job to continue with a node failure.  VCs associated with the failed process enter a failed state, and cannot be used for communication, but communication is still allowed with other processes.  Reviewed by goodell@.

[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

This ticket also converts the MPIDI_Request_recv_pending macro into two
macros which have slightly clearer names and usages.  The side effect of
the old macro was very confusing.

Reviewed by buntinas@.

[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

No reviewer.

[svn-r3717] Added ATTRIBUTE((unused)) in several places; removed unused variables and code; added some fixmes

[svn-r3275] Updates for brief-global thread cs support (still requires updates to MPIR_Localcopy) and for new match structure defintion where used within debugging statements

[svn-r3070] Added ATTRIBUTE((unused)) (which is defined to work with gcc and disappear for other compilers only to the functions whose arguments are defined by a general pattern (such as a request handler) and thus must be used even if not needed.  For functions that have parameters that are not used and are not needed to conform to a pattern, do not use ATTRIBUTE((unused)), instead, fix the routine to either make use of the argument in a real way or change the routine to not pass the argument.