mpi: made MPI-error-checking macro an inline function

this is a little more C++-like and IMHO a little nicer

Signed-off-by: Torbjörn Klatt <[email protected]>

Author: torbjoernk

include/pfasst/mpi_communicator.hpp

@@ -47,6 +47,19 @@ namespace pfasst
         static MPIError from_code(const int err_code);
     };
 
+    /**
+     * checks MPI error code
+     *
+     * In case @p err_code is not `MPI_SUCCESS` this throws MPIError with the error code looked up
+     * to a descriptive string as defined by the MPI implementation.
+     */
+    inline static void check_mpi_error(const int err_code)
+    {
+      if (err_code != MPI_SUCCESS) {
+        throw MPIError::from_code(err_code);
+      }
+    }
+
 
     // forward declare for MPICommunicator
     class MPIStatus;

src/pfasst/encap/vector_impl.hpp

@@ -3,10 +3,6 @@
 
 #include "pfasst/encap/vector.hpp"
 
-#ifdef WITH_MPI
-#define CHKMPIERR(err) if (err != MPI_SUCCESS) { throw MPIError::from_code(err); }
-#endif
-
 namespace pfasst
 {
   namespace encap
@@ -45,7 +41,7 @@ namespace pfasst
       if (this->send_request != MPI_REQUEST_NULL) {
         MPI_Status stat;
         int err = MPI_Wait(&(this->send_request), &stat);
-        CHKMPIERR(err);
+        check_mpi_error(err);
       }
       assert(this->recv_request == MPI_REQUEST_NULL);
       assert(this->send_request == MPI_REQUEST_NULL);
@@ -191,13 +187,13 @@ namespace pfasst
       if (mpi.rank() == 0) { return; }
 
       if (this->recv_request != MPI_REQUEST_NULL) {
-        throw MPIError();
+        throw MPIError("a previous recieve request is still open");
       }
 
       int src = (mpi.rank() - 1) % mpi.size();
       int err = MPI_Irecv(this->data(), sizeof(scalar) * this->size(), MPI_CHAR,
                       src, tag, mpi.comm, &this->recv_request);
-      CHKMPIERR(err);
+      check_mpi_error(err);
     }
 
     template<typename scalar, typename time>
@@ -214,11 +210,12 @@ namespace pfasst
         int src = (mpi.rank() - 1) % mpi.size();
         err = MPI_Recv(this->data(), sizeof(scalar) * this->size(), MPI_CHAR,
                        src, tag, mpi.comm, &stat);
-        CHKMPIERR(err);
+        check_mpi_error(err);
       } else {
         if (this->recv_request != MPI_REQUEST_NULL) {
           CLOG(DEBUG, "Encap") << "waiting on last recv request";
-          err = MPI_Wait(&(this->recv_request), &stat); CHKMPIERR(err);
+          err = MPI_Wait(&(this->recv_request), &stat);
+          check_mpi_error(err);
           CLOG(DEBUG, "Encap") << "waiting done: " << stat;
         }
       }
@@ -237,24 +234,23 @@ namespace pfasst
 
       if (blocking) {
         err = MPI_Send(this->data(), sizeof(scalar) * this->size(), MPI_CHAR, dest, tag, mpi.comm);
-        CHKMPIERR(err);
+        check_mpi_error(err);
       } else {
         err = MPI_Wait(&(this->send_request), &stat);
-        CHKMPIERR(err);
+        check_mpi_error(err);
         err = MPI_Isend(this->data(), sizeof(scalar) * this->size(), MPI_CHAR,
                         dest, tag, mpi.comm, &(this->send_request));
-        CHKMPIERR(err);
+        check_mpi_error(err);
       }
-
     }
 
     template<typename scalar, typename time>
     void VectorEncapsulation<scalar, time>::broadcast(ICommunicator* comm)
     {
       auto& mpi = as_mpi(comm);
       int err = MPI_Bcast(this->data(), sizeof(scalar) * this->size(), MPI_CHAR,
-                          comm->size()-1, mpi.comm); CHKMPIERR(err);
-      CHKMPIERR(err);
+                          comm->size()-1, mpi.comm);
+      check_mpi_error(err);
     }
 #endif
 

src/pfasst/mpi_communicator_impl.hpp

@@ -20,7 +20,8 @@ namespace pfasst
     {
       char err_str[MPI_MAX_ERROR_STRING];
       int err_len = 0;
-      MPI_Error_string(err_code, err_str, &err_len);
+      int err = MPI_Error_string(err_code, err_str, &err_len);
+      check_mpi_error(err);
       return MPIError("MPI Error: " + string(err_str, err_len) + " (code=" + to_string(err_code) + ")");
     }
 
@@ -40,7 +41,8 @@ namespace pfasst
       MPI_Comm_rank(this->comm, &(this->_rank));
       int len = 0;
       char buff[MPI_MAX_OBJECT_NAME];
-      MPI_Comm_get_name(this->comm, buff, &len);
+      int err = MPI_Comm_get_name(this->comm, buff, &len);
+      check_mpi_error(err);
       if (len == 0) {
         this->_name = string("world");
       } else {
@@ -109,7 +111,7 @@ namespace pfasst
       int dest_rank = (mpi->rank() + 1) % mpi->size();
 
       int err = MPI_Send(&iconverged, sizeof(int), MPI_INT, dest_rank, 1, mpi->comm);
-      if (err != MPI_SUCCESS) { throw MPIError::from_code(err); }
+      check_mpi_error(err);
     }
 
     void MPIStatus::recv()
@@ -127,7 +129,7 @@ namespace pfasst
       int iconverged;
       int src_rank = (mpi->rank() - 1) % mpi->size();
       int err = MPI_Recv(&iconverged, sizeof(iconverged), MPI_INT, src_rank, 1, mpi->comm, &stat);
-      if (err != MPI_SUCCESS) { throw MPIError::from_code(err); }
+      check_mpi_error(err);
 
       converged.at(mpi->rank() - 1) = (iconverged == IStatus::CONVERGED) ? true : false;
     }
@@ -142,9 +144,13 @@ MAKE_LOGGABLE(MPI_Status, mpi_status, os)
       && mpi_status.MPI_ERROR == MPI_SUCCESS) {
     os << "MPI_Status(empty)";
   } else {
+    char err_str[MPI_MAX_ERROR_STRING];
+    int err_len = 0;
+    int err = MPI_Error_string(mpi_status.MPI_ERROR, err_str, &err_len);
+    pfasst::mpi::check_mpi_error(err);
     os << "MPI_Status(source=" << to_string(mpi_status.MPI_SOURCE) << ", "
                   << "tag=" << to_string(mpi_status.MPI_TAG) << ", "
-                  << "error=" << to_string(mpi_status.MPI_ERROR) << ")";
+                  << "error=" << string(err_str, err_len) << ")";
   }
   return os;
 }