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

@@ -28,7 +28,7 @@ class AxpyInterface
 public:
     AxpyInterface();
     ~AxpyInterface();
-
+   
     AxpyInterface( AxpyType type,       DistMatrix<T,MC,MR>& Z );
     AxpyInterface( AxpyType type, const DistMatrix<T,MC,MR>& Z ); 
 
@@ -41,48 +41,66 @@ class AxpyInterface
     void Detach();
 
 private:
+#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_;
-
-    vector<deque<vector<byte>>> dataVectors_, requestVectors_, replyVectors_;
-    vector<deque<bool>> sendingData_, sendingRequest_, sendingReply_;
-    vector<deque<mpi::Request>> 
+#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_;
-
+
+    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