Testing: RMA AxpyInterface

CMakeLists.txt

@@ -83,6 +83,11 @@ option(EL_USE_64BIT_INTS "Use 64-bit integers where possible" OFF)
 option(EL_USE_CUSTOM_ALLTOALLV "Avoid MPI_Alltoallv for performance reasons" ON)
 option(EL_BARRIER_IN_ALLTOALLV "Barrier before posting non-blocking recvs" OFF)
 
+# MPI misc.
+# Enable MPI-3 routines
+option(EL_ENABLE_RMA_AXPY "Choose new Rma Axpy interface implemented using MPI-3 one sided routines" ON)
+option(EL_USE_IBARRIER_FOR_AXPY "Use MPI-3 IBarrier for synchronization in AxpyInterface" ON)
+
 # If the version of METIS packaged with Elemental is to be built (the default),
 # then no METIS-specific variables need to be specified, but if the user prefers
 # to use their own version, then the root path of the installation should be

cmake/config.h.cmake

@@ -79,6 +79,11 @@
 #cmakedefine EL_VECTOR_WARNINGS
 #cmakedefine EL_AVOID_OMP_FMA
 
+/* MPI-3 related */
+#cmakedefine EL_ENABLE_RMA_AXPY
+#cmakedefine EL_USE_IBARRIER_FOR_AXPY
+
+
 #cmakedefine EL_DECLSPEC
 #ifdef EL_DECLSPEC
 # define EL_EXPORT __declspec(dllexport)

include/El/core.hpp

@@ -151,6 +151,8 @@ template<typename T=double,Dist U=MC,Dist V=MR> class BlockDistMatrix;
 #include "El/core/random/decl.hpp"
 #include "El/core/random/impl.hpp"
 #include "El/core/AxpyInterface.hpp"
+#include "El/core/RmaInterface.hpp"
+#include "El/core/AxpyInterface2.0.hpp"
 
 #include "El/core/Graph.hpp"
 // TODO: Sequential map

include/El/core/AxpyInterface.hpp

@@ -7,8 +7,8 @@
    This interface is mainly due to Martin Schatz, but it was put into its
    current form by Jack Poulson.
 
-   This file is part of Elemental and is under the BSD 2-Clause License, 
-   which can be found in the LICENSE file in the root directory, or at 
+   This file is part of Elemental and is under the BSD 2-Clause License,
+   which can be found in the LICENSE file in the root directory, or at
    http://opensource.org/licenses/BSD-2-Clause
 */
 #pragma once
@@ -24,65 +24,83 @@ using namespace AxpyTypeNS;
 
 template<typename T>
 class AxpyInterface
-{   
+{
 public:
     AxpyInterface();
     ~AxpyInterface();
 
     AxpyInterface( AxpyType type,       DistMatrix<T,MC,MR>& Z );
-    AxpyInterface( AxpyType type, const DistMatrix<T,MC,MR>& Z ); 
+    AxpyInterface( AxpyType type, const DistMatrix<T,MC,MR>& Z );
 
-    void Attach( AxpyType type,       DistMatrix<T,MC,MR>& Z ); 
-    void Attach( AxpyType type, const DistMatrix<T,MC,MR>& Z ); 
+    void Attach( AxpyType type,       DistMatrix<T,MC,MR>& Z );
+    void Attach( AxpyType type, const DistMatrix<T,MC,MR>& Z );
 
     void Axpy( T alpha,       Matrix<T>& Z, Int i, Int j );
     void Axpy( T alpha, const Matrix<T>& Z, Int i, Int j );
 
     void Detach();
 
 private:
-    static const Int 
-        DATA_TAG        =1, 
-        EOM_TAG         =2, 
-        DATA_REQUEST_TAG=3, 
-        DATA_REPLY_TAG  =4;
-
+#if MPI_VERSION>=3 && defined(EL_USE_IBARRIER_FOR_AXPY)
+    static const Int
+    DATA_TAG        =1,
+    DATA_REQUEST_TAG=2,
+    DATA_REPLY_TAG  =3;
+#else
+    static const Int
+    DATA_TAG        =1,
+    EOM_TAG         =2,
+    DATA_REQUEST_TAG=3,
+    DATA_REPLY_TAG  =4;
+#endif
+
+    //request object for polling on Issends
     bool attachedForLocalToGlobal_, attachedForGlobalToLocal_;
+
     DistMatrix<T,MC,MR>* localToGlobalMat_;
     const DistMatrix<T,MC,MR>* globalToLocalMat_;
 
-    vector<bool> sentEomTo_, haveEomFrom_;
-    vector<byte> recvVector_;
-    vector<mpi::Request> eomSendRequests_;
+#if MPI_VERSION>=3 && defined(EL_USE_IBARRIER_FOR_AXPY)
+#else
+    std::vector<bool> sentEomTo_, haveEomFrom_;
+    std::vector<mpi::Request> eomSendRequests_;
+#endif
+
+    std::vector<std::deque<bool>>
+                               sendingData_, sendingRequest_, sendingReply_;
+    std::vector<std::deque<mpi::Request>>
+                                       dataSendRequests_, requestSendRequests_, replySendRequests_;
 
-    vector<deque<vector<byte>>> dataVectors_, requestVectors_, replyVectors_;
-    vector<deque<bool>> sendingData_, sendingRequest_, sendingReply_;
-    vector<deque<mpi::Request>> 
-        dataSendRequests_, requestSendRequests_, replySendRequests_;
+    std::vector<byte> recvVector_;
+    std::vector<std::deque<std::vector<byte>>>
+    dataVectors_, requestVectors_, replyVectors_;
 
     byte sendDummy_, recvDummy_;
 
+    // Progress functions
+#if MPI_VERSION>=3 && defined(EL_USE_IBARRIER_FOR_AXPY)
+    bool ReturnRequestStatuses();
+#else
     // Check if we are done with this attachment's work
     bool Finished();
-
-    // Progress functions
-    void UpdateRequestStatuses();
     void HandleEoms();
-    void HandleLocalToGlobalData();
-    void HandleGlobalToLocalRequest();
     void StartSendingEoms();
     void FinishSendingEoms();
-
-    void AxpyLocalToGlobal( T alpha, const Matrix<T>& X, Int i, Int j );
-    void AxpyGlobalToLocal( T alpha,       Matrix<T>& Y, Int i, Int j );
+    void UpdateRequestStatuses();
+#endif
 
     Int ReadyForSend
     ( Int sendSize,
-      deque<vector<byte>>& sendVectors,
-      deque<mpi::Request>& requests, 
-      deque<bool>& requestStatuses );
+      std::deque<std::vector<byte>>& sendVectors,
+      std::deque<mpi::Request>& requests,
+      std::deque<bool>& requestStatuses );
+
+    void HandleLocalToGlobalData();
+    void HandleGlobalToLocalRequest();
+
+    void AxpyLocalToGlobal( T alpha, const Matrix<T>& X, Int i, Int j );
+    void AxpyGlobalToLocal( T alpha,       Matrix<T>& Y, Int i, Int j );
 };
 
 } // namespace El
-
 #endif // ifndef EL_AXPYINTERFACE_HPP

include/El/core/AxpyInterface2.0.hpp

@@ -0,0 +1,147 @@
+/*
+   This file is part of Elemental and is under the BSD 2-Clause License,
+   which can be found in the LICENSE file in the root directory, or at
+   http://opensource.org/licenses/BSD-2-Clause
+*/
+#pragma once
+#ifndef EL_AXPYINTERFACE2_HPP
+#define EL_AXPYINTERFACE2_HPP
+
+namespace El {
+template<typename T>
+class AxpyInterface2
+{
+public:
+    AxpyInterface2();
+    ~AxpyInterface2();
+
+    AxpyInterface2(       DistMatrix<T,MC,MR>& Z );
+    AxpyInterface2( const DistMatrix<T,MC,MR>& Z );
+
+    // collective epoch initialization routines
+    void Attach(       DistMatrix<T,MC,MR>& Z );
+    void Attach( const DistMatrix<T,MC,MR>& Z );
+    void Detach();
+
+    // remote update routines
+
+    // requires Flush for local+remote
+    // completion
+    void Iput(       Matrix<T>& Z, Int i, Int j );
+    void Iput( const Matrix<T>& Z, Int i, Int j );
+
+    void Iget(       Matrix<T>& Z, Int i, Int j );
+
+    void Iacc(       Matrix<T>& Z, Int i, Int j );
+    void Iacc( const Matrix<T>& Z, Int i, Int j );
+
+    // locally blocking update routines
+    // reuse input buffer when returns
+    void Acc(       Matrix<T>& Z, Int i, Int j );
+    void Acc( const Matrix<T>& Z, Int i, Int j );
+
+    void Put(       Matrix<T>& Z, Int i, Int j );
+    void Put( const Matrix<T>& Z, Int i, Int j );
+
+    // End to End blocking
+    // will be deprecated soon
+    void Eacc(       Matrix<T>& Z, Int i, Int j );
+    void Eacc( const Matrix<T>& Z, Int i, Int j );
+
+    void Eput(       Matrix<T>& Z, Int i, Int j );
+    void Eput( const Matrix<T>& Z, Int i, Int j );
+
+    void Get(       Matrix<T>& Z, Int i, Int j );
+
+    // synchronization routines
+    void Flush(          Matrix<T>& Z );
+    void Flush(    const Matrix<T>& Z );
+
+private:
+
+    static const Int
+    DATA_PUT_TAG      =1,
+    DATA_GET_TAG      =2,
+    DATA_ACC_TAG      =3,
+    REQUEST_GET_TAG   =4,
+    COORD_ACC_TAG     =5,
+    COORD_PUT_TAG     =6;
+
+    // struct for passing data
+    struct matrix_params_
+    {
+        const void *base_;
+        std::vector<std::deque<std::vector<T>>>
+        data_;
+        std::vector<std::deque<mpi::Request>>
+                                           requests_;
+        std::vector<std::deque<bool>>
+                                   statuses_;
+    };
+
+    std::vector<struct matrix_params_> matrices_;
+
+    // struct for passing coordinates
+    struct coord_params_
+    {
+        const void *base_;
+        std::vector<std::deque<std::array<Int, 3>>>
+        coord_;
+        std::vector<std::deque<mpi::Request>>
+                                           requests_;
+        std::vector<std::deque<bool>>
+                                   statuses_;
+    };
+
+    std::vector<struct coord_params_> coords_;
+
+    // for blocking interface
+    // copying input buffer in this
+    // intermediate buffer so that input
+    // buffer could be reused
+    std::vector<std::vector<std::vector< T >>>
+    dataVectors_;
+
+    DistMatrix<T,MC,MR>* GlobalArrayPut_;
+    const DistMatrix<T,MC,MR>* GlobalArrayGet_;
+
+    bool toBeAttachedForPut_, toBeAttachedForGet_,
+         attached_, detached_;
+
+    // next index for data and coord
+    Int NextIndexData (
+        Int target,
+        Int dataSize,
+        const void* base_address,
+        Int *mindex );
+
+    Int NextIndexCoord (
+        Int i, Int j,
+        Int target,
+        const void* base_address,
+        Int *cindex );
+
+    bool Testall();
+    bool Test(             Matrix<T>& Z );
+    bool Test(       const Matrix<T>& Z );
+    bool TestAny(          Matrix<T>& Z );
+    bool TestAny(    const Matrix<T>& Z );
+
+    void Waitall();
+    void Wait(             Matrix<T>& Z );
+    void Wait(       const Matrix<T>& Z );
+    void WaitAny(          Matrix<T>& Z );
+    void WaitAny(    const Matrix<T>& Z );
+
+    // these are only used for nonblocking
+    // update rountines
+    void HandleGlobalToLocalData( Matrix<T>& Z );
+
+    void HandleLocalToGlobalData( Matrix<T>& Z, Int source );
+    void HandleLocalToGlobalAcc(  Matrix<T>& Z, Int source );
+
+    void HandleLocalToGlobalData( const Matrix<T>& Z, Int source );
+    void HandleLocalToGlobalAcc(  const Matrix<T>& Z, Int source );
+};
+} // namespace El
+#endif // ifndef EL_AXPYINTERFACE2_HPP