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:
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#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/parallel/future.hh>


 
namespace Dune
{
 
  /* define some type that definitely differs from MPI_Comm */
  struct No_Comm {};

  inline bool operator==(const No_Comm&, const No_Comm&)
  {
    return true;
  }

  inline bool operator!=(const No_Comm&, const No_Comm&)
  {
    return false;
  }

  template<typename Communicator>
  class Communication
  {
  public:
    Communication()
    {}

    Communication (const Communicator&)
    {}

    int rank () const
    {
      return 0;
    }

    operator No_Comm() const
    {
      return {};
    }

    int size () const
    {
      return 1;
    }

    template<class T>
    int send([[maybe_unused]] const T& data,
             [[maybe_unused]] int dest_rank,
             [[maybe_unused]] int tag) const
    {
      DUNE_THROW(ParallelError, "This method is not supported in sequential programs");
    }

    template<class T>
    PseudoFuture<T> isend([[maybe_unused]] T&& data,
                          [[maybe_unused]] int dest_rank,
                          [[maybe_unused]] int tag) const
    {
      DUNE_THROW(ParallelError, "This method is not supported in sequential programs");
    }

    template<class T>
    T recv([[maybe_unused]] T&& data,
           [[maybe_unused]] int source_rank,
           [[maybe_unused]] int tag,
           [[maybe_unused]] void* status = 0) const
    {
      DUNE_THROW(ParallelError, "This method is not supported in sequential programs");
    }

    template<class T>
    PseudoFuture<T> irecv([[maybe_unused]] T&& data,
                          [[maybe_unused]] int source_rank,
                          [[maybe_unused]] int tag) const
    {
      DUNE_THROW(ParallelError, "This method is not supported in sequential programs");
    }
 
    template<class T>
    T rrecv([[maybe_unused]] T&& data,
            [[maybe_unused]] int source_rank,
            [[maybe_unused]] int tag,
            [[maybe_unused]] void* status = 0) const
    {
      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 ([[maybe_unused]] T* inout, [[maybe_unused]] int len) const
    {
      return 0;
    }

    template<typename T>
    T prod (const T& in) const
    {
      return in;
    }

    template<typename T>
    int prod ([[maybe_unused]] T* inout, [[maybe_unused]] int len) const
    {
      return 0;
    }

    template<typename T>
    T min (const T& in) const
    {
      return in;
    }

    template<typename T>
    int min ([[maybe_unused]] T* inout, [[maybe_unused]] int len) const
    {
      return 0;
    }

    template<typename T>
    T max (const T& in) const
    {
      return in;
    }

    template<typename T>
    int max ([[maybe_unused]] T* inout, [[maybe_unused]] int len) const
    {
      return 0;
    }

    int barrier () const
    {
      return 0;
    }

    PseudoFuture<void> ibarrier () const
    {
      return {true}; // return a valid future
    }

    template<typename T>
    int broadcast ([[maybe_unused]] T* inout,
                   [[maybe_unused]] int len,
                   [[maybe_unused]] int root) const
    {
      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
    {
      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 sendDataLen,
                 T* out,
                 [[maybe_unused]] int* recvDataLen,
                 int* displ,
                 [[maybe_unused]] int root) const
    {
      for (int i=*displ; i<sendDataLen; i++)
        out[i] = in[i];
      return 0;
    }

    template<typename T>
    int scatter (const T* sendData, T* recvData, int len, int /*root*/) const // note out must have same size as in
    {
      for (int i=0; i<len; i++)
        recvData[i] = sendData[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* sendData,int* sendDataLen, int* displ, T* recvData,
                  [[maybe_unused]] int recvDataLen, [[maybe_unused]] int root) const
    {
      for (int i=*displ; i<*sendDataLen; i++)
        recvData[i] = sendData[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 sendDataLen, T* out, [[maybe_unused]] int* recvDataLen, int* displ) const
    {
      for (int i=*displ; i<sendDataLen; i++)
        out[i] = in[i];
      return 0;
    }

    template<typename BinaryFunction, typename Type>
    int allreduce([[maybe_unused]] Type* inout, [[maybe_unused]] int len) const
    {
      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;
    }
 
  };
}
 
#endif // DUNE_COMMON_PARALLEL_COMMUNICATION_HH