Communication.hpp

Go to the documentation of this file.

#pragma once
 
#include <set>
#include <stddef.h>
#include <string>
#include <vector>
 
#include "boost/range/irange.hpp"
#include "com/Request.hpp"
#include "com/SharedPointer.hpp"
#include "logging/Logger.hpp"
#include "precice/impl/Types.hpp"
#include "precice/span.hpp"
 
namespace precice {
namespace com {
 
template <typename T>
struct AsVectorTag {
};
 
/* TODO When moving to C++17 use inline variable:
 *
 * template<typename T>
 * inline constexpr auto asVector = Communication::AsVectorTag<T>{};
 */
 
class Communication {
 
public:
  Communication &operator=(Communication &&) = delete;
 
  virtual ~Communication()
  {
  }
 
 
  virtual bool isConnected()
  {
    return _isConnected;
  }
 
  virtual size_t getRemoteCommunicatorSize() = 0;
 
  auto remoteCommunicatorRanks()
  {
    return boost::irange<Rank>(0, static_cast<Rank>(getRemoteCommunicatorSize()));
  }
 
  virtual void acceptConnection(std::string const &acceptorName,
                                std::string const &requesterName,
                                std::string const &tag,
                                int                acceptorRank,
                                int                rankOffset = 0) = 0;
 
  virtual void acceptConnectionAsServer(std::string const &acceptorName,
                                        std::string const &requesterName,
                                        std::string const &tag,
                                        int                acceptorRank,
                                        int                requesterCommunicatorSize) = 0;
 
  virtual void requestConnection(std::string const &acceptorName,
                                 std::string const &requesterName,
                                 std::string const &tag,
                                 int                requesterRank,
                                 int                requesterCommunicatorSize) = 0;
 
  virtual void requestConnectionAsClient(std::string const &  acceptorName,
                                         std::string const &  requesterName,
                                         std::string const &  tag,
                                         std::set<int> const &acceptorRanks,
                                         int                  requesterRank) = 0;
 
  void connectIntraComm(std::string const &participantName,
                        std::string const &tag,
                        int                rank,
                        int                size);
 
  virtual void closeConnection() = 0;
 
  virtual void prepareEstablishment(std::string const &acceptorName,
                                    std::string const &requesterName) {}
 
  virtual void cleanupEstablishment(std::string const &acceptorName,
                                    std::string const &requesterName) {}
 
 
 
  virtual void reduceSum(precice::span<double const> itemsToSend, precice::span<double> itemsToReceive, Rank primaryRank);
  virtual void reduceSum(precice::span<double const> itemsToSend, precice::span<double> itemsToReceive);
 
  virtual void reduceSum(int itemToSend, int &itemToReceive, Rank primaryRank);
  virtual void reduceSum(int itemsToSend, int &itemsToReceive);
 
  virtual void allreduceSum(precice::span<double const> itemsToSend, precice::span<double> itemsToReceive, Rank primaryRank);
  virtual void allreduceSum(precice::span<double const> itemsToSend, precice::span<double> itemsToReceive);
 
  virtual void allreduceSum(double itemToSend, double &itemToReceive, Rank primaryRank);
  virtual void allreduceSum(double itemToSend, double &itemToReceive);
 
  virtual void allreduceSum(int itemToSend, int &itemToReceive, Rank primaryRank);
  virtual void allreduceSum(int itemToSend, int &itemToReceive);
 
 
 
  virtual void broadcast(precice::span<const int> itemsToSend);
  virtual void broadcast(precice::span<int> itemsToReceive, Rank rankBroadcaster);
 
  virtual void broadcast(int itemToSend);
  virtual void broadcast(int &itemToReceive, Rank rankBroadcaster);
 
  virtual void broadcast(precice::span<const double> itemsToSend);
  virtual void broadcast(precice::span<double> itemsToReceive, Rank rankBroadcaster);
 
  virtual void broadcast(double itemToSend);
  virtual void broadcast(double &itemToReceive, Rank rankBroadcaster);
 
  virtual void broadcast(bool itemToSend);
  virtual void broadcast(bool &itemToReceive, Rank rankBroadcaster);
 
  virtual void broadcast(std::vector<int> const &v);
  virtual void broadcast(std::vector<int> &v, Rank rankBroadcaster);
 
  virtual void broadcast(std::vector<double> const &v);
  virtual void broadcast(std::vector<double> &v, Rank rankBroadcaster);
 
 
 
  virtual void send(std::string const &itemToSend, Rank rankReceiver) = 0;
 
  virtual void send(precice::span<const int> itemsToSend, Rank rankReceiver) = 0;
 
  virtual PtrRequest aSend(precice::span<const int> itemsToSend, Rank rankReceiver) = 0;
 
  virtual void send(precice::span<const double> itemsToSend, Rank rankReceiver) = 0;
 
  virtual PtrRequest aSend(precice::span<const double> itemsToSend, Rank rankReceiver) = 0;
 
  virtual void send(double itemToSend, Rank rankReceiver) = 0;
 
  virtual PtrRequest aSend(const double &itemToSend, Rank rankReceiver) = 0;
 
  virtual void send(int itemToSend, Rank rankReceiver) = 0;
 
  virtual PtrRequest aSend(const int &itemToSend, Rank rankReceiver) = 0;
 
  virtual void send(bool itemToSend, Rank rankReceiver) = 0;
 
  virtual PtrRequest aSend(const bool &itemToSend, Rank rankReceiver) = 0;
 
 
 
  virtual void receive(std::string &itemToReceive, Rank rankSender) = 0;
 
  virtual void receive(precice::span<int> itemsToReceive, Rank rankSender) = 0;
 
  virtual void receive(precice::span<double> itemsToReceive, Rank rankSender) = 0;
 
  virtual PtrRequest aReceive(precice::span<double> itemsToReceive, int rankSender) = 0;
 
  virtual void receive(double &itemToReceive, Rank rankSender) = 0;
 
  virtual PtrRequest aReceive(double &itemToReceive, Rank rankSender) = 0;
 
  virtual void receive(int &itemToReceive, Rank rankSender) = 0;
 
  virtual PtrRequest aReceive(int &itemToReceive, Rank rankSender) = 0;
 
  virtual void receive(bool &itemToReceive, Rank rankSender) = 0;
 
  virtual PtrRequest aReceive(bool &itemToReceive, Rank rankSender) = 0;
 
 
 
  void sendRange(precice::span<const double> itemsToSend, Rank rankReceiver);
 
  void sendRange(precice::span<const int> itemsToSend, Rank rankReceiver);
 
  std::vector<int> receiveRange(Rank rankSender, AsVectorTag<int>);
 
  std::vector<double> receiveRange(Rank rankSender, AsVectorTag<double>);
 
 
  void setRankOffset(Rank rankOffset)
  {
    _rankOffset = rankOffset;
  }
 
protected:
  int _rankOffset = 0;
 
  bool _isConnected = false;
 
  virtual int adjustRank(Rank rank) const;
 
private:
  logging::Logger _log{"com::Communication"};
};
 
void connectCircularComm(
    std::string const & participantName,
    std::string const & tag,
    int                 rank,
    int                 size,
    com::Communication &left,
    com::Communication &right);
 
} // namespace com
} // namespace precice