communication.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_COMMON_PARALLEL_COMMUNICATION_HH
#define DUNE_COMMON_PARALLEL_COMMUNICATION_HH
#include <iostream>
#include <complex>
#include <algorithm>
#include <vector>
 
#include <dune/common/binaryfunctions.hh>
#include <dune/common/exceptions.hh>
#include <dune/common/unused.hh>
#include <dune/common/parallel/future.hh>
 
namespace Dune
{
 
  /* define some type that definitely differs from MPI_Comm */
  struct No_Comm {};
 
  template<typename Communicator>
  class Communication
  {
  public:
    Communication()
    {}
 
    Communication (const Communicator&)
    {}
 
    int rank () const
    {
      return 0;
    }
 
    int size () const
    {
      return 1;
    }
 
    template<class T>
    int send(const T& data, int dest_rank, int tag){
      DUNE_UNUSED_PARAMETER(data);
      DUNE_UNUSED_PARAMETER(dest_rank);
      DUNE_UNUSED_PARAMETER(tag);
      DUNE_THROW(ParallelError, "This method is not supported in sequential programs");
    }
 
    template<class T>
    PseudoFuture<T> isend(const T&& data, int dest_rank, int tag){
      DUNE_UNUSED_PARAMETER(data);
      DUNE_UNUSED_PARAMETER(dest_rank);
      DUNE_UNUSED_PARAMETER(tag);
      DUNE_THROW(ParallelError, "This method is not supported in sequential programs");
    }
 
    template<class T>
    T recv(T&& data, int source_rank, int tag, void* status = 0){
      DUNE_UNUSED_PARAMETER(data);
      DUNE_UNUSED_PARAMETER(source_rank);
      DUNE_UNUSED_PARAMETER(tag);
      DUNE_UNUSED_PARAMETER(status);
      DUNE_THROW(ParallelError, "This method is not supported in sequential programs");
    }
 
    template<class T>
    PseudoFuture<T> irecv(T&& data, int source_rank, int tag){
      DUNE_UNUSED_PARAMETER(data);
      DUNE_UNUSED_PARAMETER(source_rank);
      DUNE_UNUSED_PARAMETER(tag);
      DUNE_THROW(ParallelError, "This method is not supported in sequential programs");
    }
 
    template<class T>
    T rrecv(T&& data, int source_rank, int tag, void* status = 0) const
    {
      DUNE_UNUSED_PARAMETER(data);
      DUNE_UNUSED_PARAMETER(source_rank);
      DUNE_UNUSED_PARAMETER(tag);
      DUNE_UNUSED_PARAMETER(status);
      DUNE_THROW(ParallelError, "This method is not supported in sequential programs");
    }
    template<typename T>
    T sum (const T& in) const
    {
      return in;
    }
 
    template<typename T>
    int sum (T* inout, int len) const
    {
      DUNE_UNUSED_PARAMETER(inout);
      DUNE_UNUSED_PARAMETER(len);
      return 0;
    }
 
    template<typename T>
    T prod (const T& in) const
    {
      return in;
    }
 
    template<typename T>
    int prod (T* inout, int len) const
    {
      DUNE_UNUSED_PARAMETER(inout);
      DUNE_UNUSED_PARAMETER(len);
      return 0;
    }
 
    template<typename T>
    T min (const T& in) const
    {
      return in;
    }
 
    template<typename T>
    int min (T* inout, int len) const
    {
      DUNE_UNUSED_PARAMETER(inout);
      DUNE_UNUSED_PARAMETER(len);
      return 0;
    }
 
    template<typename T>
    T max (const T& in) const
    {
      return in;
    }
 
    template<typename T>
    int max (T* inout, int len) const
    {
      DUNE_UNUSED_PARAMETER(inout);
      DUNE_UNUSED_PARAMETER(len);
      return 0;
    }
 
    int barrier () const
    {
      return 0;
    }
 
    PseudoFuture<void> ibarrier () const
    {
      return {true}; // return a valid future
    }
 
    template<typename T>
    int broadcast (T* inout, int len, int root) const
    {
      DUNE_UNUSED_PARAMETER(inout);
      DUNE_UNUSED_PARAMETER(len);
      DUNE_UNUSED_PARAMETER(root);
      return 0;
    }
 
    template<class T>
    PseudoFuture<T> ibroadcast(T&& data, int root) const{
      return {std::forward<T>(data)};
    }
 
 
    template<typename T>
    int gather (const T* in, T* out, int len, int root) const     // note out must have same size as in
    {
      DUNE_UNUSED_PARAMETER(root);
      for (int i=0; i<len; i++)
        out[i] = in[i];
      return 0;
    }
 
    template<class TIN, class TOUT = std::vector<TIN>>
    PseudoFuture<TOUT> igather(TIN&& data_in, TOUT&& data_out, int root){
      *(data_out.begin()) = std::forward<TIN>(data_in);
      return {std::forward<TOUT>(data_out)};
    }
 
 
    template<typename T>
    int gatherv (const T* in, int sendlen, T* out, int* recvlen, int* displ, int root) const
    {
      DUNE_UNUSED_PARAMETER(recvlen);
      DUNE_UNUSED_PARAMETER(root);
      for (int i=*displ; i<sendlen; i++)
        out[i] = in[i];
      return 0;
    }
 
    template<typename T>
    int scatter (const T* send, T* recv, int len, int root) const // note out must have same size as in
    {
      DUNE_UNUSED_PARAMETER(root);
      for (int i=0; i<len; i++)
        recv[i] = send[i];
      return 0;
    }
 
    template<class TIN, class TOUT = TIN>
    PseudoFuture<TOUT> iscatter(TIN&& data_in, TOUT&& data_out, int root){
      data_out = *(std::forward<TIN>(data_in).begin());
      return {std::forward<TOUT>(data_out)};
    }
 
    template<typename T>
    int scatterv (const T* send, int* sendlen, int* displ, T* recv, int recvlen, int root) const
    {
      DUNE_UNUSED_PARAMETER(recvlen);
      DUNE_UNUSED_PARAMETER(root);
      for (int i=*displ; i<*sendlen; i++)
        recv[i] = send[i];
      return 0;
    }
 
    template<typename T>
    int allgather(const T* sbuf, int count, T* rbuf) const
    {
      for(const T* end=sbuf+count; sbuf < end; ++sbuf, ++rbuf)
        *rbuf=*sbuf;
      return 0;
    }
 
    template<class TIN, class TOUT = TIN>
    PseudoFuture<TOUT> iallgather(TIN&& data_in, TOUT&& data_out){
      return {std::forward<TOUT>(data_out)};
    }
 
    template<typename T>
    int allgatherv (const T* in, int sendlen, T* out, int* recvlen, int* displ) const
    {
      DUNE_UNUSED_PARAMETER(recvlen);
      for (int i=*displ; i<sendlen; i++)
        out[i] = in[i];
      return 0;
    }
 
    template<typename BinaryFunction, typename Type>
    int allreduce(Type* inout, int len) const
    {
      DUNE_UNUSED_PARAMETER(inout);
      DUNE_UNUSED_PARAMETER(len);
      return 0;
    }
 
    template<class BinaryFunction, class TIN, class TOUT = TIN>
    PseudoFuture<TOUT> iallreduce(TIN&& data_in, TOUT&& data_out){
      data_out = std::forward<TIN>(data_in);
      return {std::forward<TOUT>(data_out)};
    }
 
    template<class BinaryFunction, class T>
    PseudoFuture<T> iallreduce(T&& data){
      return {std::forward<T>(data)};
    }
 
 
    template<typename BinaryFunction, typename Type>
    int allreduce(const Type* in, Type* out, int len) const
    {
      std::copy(in, in+len, out);
      return 0;
    }
 
  };
 
  template<class T>
  using CollectiveCommunication
  // Will be deprecated after the 2.7 release
  //[[deprecated("CollectiveCommunication is deprecated. Use Communication instead.")]]
  = Communication<T>;
}
 
#endif