MpiSendRecv.h

#ifdef UTIL_MPI
#ifndef UTIL_MPI_SEND_RECV_H
#define UTIL_MPI_SEND_RECV_H
 
/*
* Util Package - C++ Utilities for Scientific Computation
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/

 
#include <util/global.h>
 
#include <util/mpi/MpiTraits.h>
#include <util/containers/DArray.h>
#include <util/containers/DMatrix.h>
 
namespace Util
{
 
   // Scalar parameters

   template <typename T>
   void send(MPI::Comm& comm, T& data, int dest, int tag)
   {
      if (!MpiTraits<T>::hasType)
         UTIL_THROW("No committed MPI type in send<T>");
      comm.Send(&data, 1, MpiTraits<T>::type, dest, tag); 
   }
  
   template <typename T>
   void recv(MPI::Comm& comm, T& data, int source, int tag)
   {  
      if (!MpiTraits<T>::hasType)
         UTIL_THROW("No committed MPI type in recv<T>");
      comm.Recv(&data, 1, MpiTraits<T>::type, source, tag); 
   }
  
   template <typename T>
   void bcast(MPI::Intracomm& comm, T& data, int root)
   {  
      if (!MpiTraits<T>::hasType)
         UTIL_THROW("No committed MPI type in bcast<T>");
      comm.Bcast(&data, 1, MpiTraits<T>::type, root); 
   }
 
   // C Array partial specializations

   template <typename T>
   void send(MPI::Comm& comm, T* array, int count, int dest, int tag)
   {  
      if (MpiTraits<T>::hasType) {
         comm.Send(array, count, MpiTraits<T>::type, dest, tag); 
      } else { 
         // Try send<T> by element, in case of explicit specialization.
         // If there is no specialization or type, send<T> throws.
         for (int i = 0; i < count; ++i) {
            send<T>(comm, array[i], dest, tag); 
         }
      }
   } 

   template <typename T>
   void recv(MPI::Comm& comm, T* array, int count, int source, int tag)
   {  
      if (MpiTraits<T>::hasType) {
         comm.Recv(array, count, MpiTraits<T>::type, source, tag); 
      } else {
         // Try recv<T> by element, in case of explicit specialization.
         // If there is no specialization or type, recv<T> throws.
         for (int i = 0; i < count; ++i) {
            recv<T>(comm, array[i], source, tag); 
         }
      }
   }

   template <typename T>
   void bcast(MPI::Intracomm& comm, T* array, int count, int root)
   {  
      if (MpiTraits<T>::hasType) {
         comm.Bcast(array, count, MpiTraits<T>::type, root); 
      } else {
         // Try bcast<T> by element, in case of explicit specialization.
         // If there is no specialization or type, bcast<T> throws.
         for (int i = 0; i < count; ++i) {
            bcast<T>(comm, array[i], root); 
         }
      }
   }
 
   // DArray container partial specializations

   template <typename T>
   void send(MPI::Comm& comm, DArray<T>& array, int count, int dest, int tag)
   {  
      // Preconditions
      if (!(array.isAllocated())) {
         UTIL_THROW("Cannot read unallocated DArray");
      }
      if (count > array.capacity()) {
         UTIL_THROW("Error: Logical size count > DArray capacity");
      }
 
      if (MpiTraits<T>::hasType) {
         comm.Send(&array[0], count, MpiTraits<T>::type, dest, tag); 
      } else {
         // Try send<T> by element, in case of explicit specialization.
         // If there is no specialization or type, send<T> throws.
         for (int i = 0; i < count; ++i) {
            send<T>(comm, array[i], dest, tag); 
         }
      }
   }
  
   template <typename T>
   void recv(MPI::Comm& comm, DArray<T>& array, int count, int source, int tag)
   {  
      // Preconditions
      if (!(array.isAllocated())) {
         UTIL_THROW("Cannot read unallocated DArray");
      }
      if (count > array.capacity()) {
         UTIL_THROW("Error: Logical size count > DArray capacity");
      }
 
      if (MpiTraits<T>::hasType) {
         comm.Recv(&array[0], count, MpiTraits<T>::type, source, tag); 
      } else {
         // Try recv<T> by element, in case of explicit specialization.
         // If there is no specialization or type, recv<T> throws.
         for (int i = 0; i < count; ++i) {
            recv<T>(comm, array[i], source, tag); 
         }
      }
   }
  
   template <typename T>
   void bcast(MPI::Intracomm& comm, DArray<T>& array, int count, int root)
   {  
      // Preconditions
      if (!(array.isAllocated())) {
         UTIL_THROW("Cannot read unallocated DArray");
      }
      if (count > array.capacity()) {
         UTIL_THROW("Error: Logical size count > DArray capacity");
      }
 
      if (MpiTraits<T>::hasType) {
         comm.Bcast(&array[0], count, MpiTraits<T>::type, root); 
      } else {
         // try bcast<T> by element, in case of explicit specialization.
         // If there is no specialization or type, bcast<T> throws.
         for (int i = 0; i < count; ++i) {
            bcast<T>(comm, array[i], root); 
         }
      }
   }
  
   // DMatrix container partial specializations

   template <typename T>
   void send(MPI::Comm& comm, DMatrix<T>& matrix, int m, int n, int dest, int tag)
   {  
      // Preconditions
      if (!(matrix.isAllocated())) {
         UTIL_THROW("Cannot read unallocated DMatrix");
      }
      if (m > matrix.capacity1()) {
         UTIL_THROW("Error: Logical size m > DMatrix<T>::capacity1()");
      }
      if (n > matrix.capacity2()) {
         UTIL_THROW("Error: Logical size n > DMatrix<T>::capacity2()");
      }
 
      if (MpiTraits<T>::hasType) {
         int mp = matrix.capacity1();
         int np = matrix.capacity2();
         comm.Send(&matrix(0, 0), mp*np, MpiTraits<T>::type, dest, tag); 
         // Note: This method sends the entire physical memory block.
      } else {
         // try send<T> by element, in case of explicit specialization.
         // If there is no specialization or type, send<T> throws.
         int i, j;
         for (i = 0; i < m; ++i) {
            for (j = 0; j < n; ++j) {
               send<T>(comm, matrix(i, j), dest, tag); 
            }
         }
      }
   }
  
   template <typename T>
   void recv(MPI::Comm& comm, DMatrix<T>& matrix, int m, int n, 
             int source, int tag)
   {  
      // Preconditions
      if (!(matrix.isAllocated())) {
         UTIL_THROW("Cannot recv unallocated DMatrix");
      }
      if (m > matrix.capacity1()) {
         UTIL_THROW("Error: Logical size m > DMatrix<T>::capacity1()");
      }
      if (n > matrix.capacity2()) {
         UTIL_THROW("Error: Logical size n > DMatrix<T>::capacity2()");
      }
 
      if (MpiTraits<T>::hasType) {
         int mp = matrix.capacity1();
         int np = matrix.capacity2();
         comm.Recv(&matrix(0, 0), mp*np, MpiTraits<T>::type, source, tag); 
         // Note: This method receives the entire physical memory block.
      } else {
         // try recv<T> by element, in case of explicit specialization.
         // If there is no specialization or type, recv<T> throws.
         int i, j;
         for (i = 0; i < m; ++i) {
            for (j = 0; j < n; ++j) {
               recv<T>(comm, matrix(i, j), source, tag); 
            }
         }
      }
   }
  
   template <typename T>
   void bcast(MPI::Intracomm& comm, DMatrix<T>& matrix, int m, int n, int root)
   {  
      // Preconditions
      if (!(matrix.isAllocated())) {
         UTIL_THROW("Cannot bcast unallocated DMatrix");
      }
      if (m > matrix.capacity1()) {
         UTIL_THROW("Error: Logical size m > DMatrix<T>::capacity1()");
      }
      if (n > matrix.capacity2()) {
         UTIL_THROW("Error: Logical size n > DMatrix<T>::capacity2()");
      }
 
      if (MpiTraits<T>::hasType) {
         int mp = matrix.capacity1();
         int np = matrix.capacity2();
         comm.Bcast(&matrix(0, 0), mp*np, MpiTraits<T>::type, root); 
         // Note: This method receives the entire physical memory block.
      } else {
         // Try bcast<T> by element, in case of explicit specialization.
         // If there is no specialization or type, bcast<T> throws.
         int i, j;
         for (i = 0; i < m; ++i) {
            for (j = 0; j < n; ++j) {
               bcast<T>(comm, matrix(i, j), root); 
            }
         }
      }
   }
 
   // bool (explicit specializations)
 
   template <>
   void send<bool>(MPI::Comm& comm, bool& data, int dest, int tag);
 
   template <>
   void recv<bool>(MPI::Comm& comm, bool& data, int source, int tag);
 
   template <>
   void bcast<bool>(MPI::Intracomm& comm, bool& data, int root);
 
   // std::string (explicit specializations)
  
   template <> void 
   send<std::string>(MPI::Comm& comm, std::string& data, int dest, int tag);
 
   template <> void 
   recv<std::string>(MPI::Comm& comm, std::string& data, int source, int tag);
 
   template <>
   void bcast<std::string>(MPI::Intracomm& comm, std::string& data, int root);
 
}
#endif
#endif