collectivecommunication.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_COLLECTIVECOMMUNICATION_HH
#define DUNE_COLLECTIVECOMMUNICATION_HH
#include <iostream>
#include <complex>
#include <algorithm>
 
#include <dune/common/binaryfunctions.hh>
#include <dune/common/exceptions.hh>
 
namespace Dune
{
 
  /* define some type that definitely differs from MPI_Comm */
  struct No_Comm {};
 
 
  template<typename Communicator>
  class CollectiveCommunication
  {
  public:
    CollectiveCommunication()
    {}
 
    CollectiveCommunication (const Communicator&)
    {}
 
    int rank () const
    {
      return 0;
    }
 
    int size () const
    {
      return 1;
    }
 
    template<typename T>
    T sum (T& in) const     // MPI does not know about const :-(
    {
      return in;
    }
 
    template<typename T>
    int sum (T* inout, int len) const
    {
      return 0;
    }
 
    template<typename T>
    T prod (T& in) const     // MPI does not know about const :-(
    {
      return in;
    }
 
    template<typename T>
    int prod (T* inout, int len) const
    {
      return 0;
    }
 
    template<typename T>
    T min (T& in) const     // MPI does not know about const :-(
    {
      return in;
    }
 
    template<typename T>
    int min (T* inout, int len) const
    {
      return 0;
    }
 
    template<typename T>
    T max (T& in) const     // MPI does not know about const :-(
    {
      return in;
    }
 
    template<typename T>
    int max (T* inout, int len) const
    {
      return 0;
    }
 
    int barrier () const
    {
      return 0;
    }
 
    template<typename T>
    int broadcast (T* inout, int len, int root) const
    {
      return 0;
    }
 
    template<typename T>
    int gather (T* in, T* out, int len, int root) const     // note out must have same size as in
    {
      for (int i=0; i<len; i++)
        out[i] = in[i];
      return 0;
    }
 
    template<typename T>
    int gatherv (T* in, int sendlen, T* out, int* recvlen, int* displ, int root) const
    {
      for (int i=*displ; i<sendlen; i++)
        out[i] = in[i];
      return 0;
    }
 
    template<typename T>
    int scatter (T* send, T* recv, int len, int root) const // note out must have same size as in
    {
      for (int i=0; i<len; i++)
        recv[i] = send[i];
      return 0;
    }
 
    template<typename T>
    int scatterv (T* send, int* sendlen, int* displ, T* recv, int recvlen, int root) const
    {
      for (int i=*displ; i<*sendlen; i++)
        recv[i] = send[i];
      return 0;
    }
 
    template<typename T>
    int allgather(T* sbuf, int count, T* rbuf) const
    {
      for(T* end=sbuf+count; sbuf < end; ++sbuf, ++rbuf)
        *rbuf=*sbuf;
      return 0;
    }
 
    template<typename T>
    int allgatherv (T* in, int sendlen, T* out, int* recvlen, int* displ) const
    {
      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
    {
      return 0;
    }
 
    template<typename BinaryFunction, typename Type>
    void allreduce(Type* in, Type* out, int len) const
    {
      std::copy(in, in+len, out);
      return;
    }
 
  };
}
 
#endif