PointToPointCommunication.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <list>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "DistributedCommunication.hpp"
#include "com/SharedPointer.hpp"
#include "logging/Logger.hpp"
#include "mesh/Mesh.hpp"
#include "mesh/SharedPointer.hpp"
 
namespace precice {
namespace com {
class Request;
} // namespace com
 
namespace m2n {
class PointToPointCommunication : public DistributedCommunication {
public:
  PointToPointCommunication(com::PtrCommunicationFactory communicationFactory,
                            mesh::PtrMesh                mesh);
 
  ~PointToPointCommunication() override;
 
  bool isConnected() const override;
 
  void acceptConnection(std::string const &acceptorName,
                        std::string const &requesterName) override;
 
  void requestConnection(std::string const &acceptorName,
                         std::string const &requesterName) override;
 
  void acceptPreConnection(std::string const &acceptorName,
                           std::string const &requesterName) override;
 
  void requestPreConnection(std::string const &acceptorName,
                            std::string const &requesterName) override;
 
  void completeSecondaryRanksConnection() override;
 
  void closeConnection() override;
 
  void send(precice::span<double const> itemsToSend, int valueDimension = 1) override;
 
  void receive(precice::span<double> itemsToReceive, int valueDimension = 1) override;
 
  void broadcastSend(int itemToSend) override;
 
  void broadcastReceiveAll(std::vector<int> &itemToReceive) override;
 
  void broadcastSendMesh() override;
 
  void broadcastReceiveAllMesh() override;
 
  void scatterAllCommunicationMap(CommunicationMap &localCommunicationMap) override;
 
  void gatherAllCommunicationMap(CommunicationMap &localCommunicationMap) override;
 
private:
  logging::Logger _log{"m2n::PointToPointCommunication"};
 
 
  void checkBufferedRequests(bool blocking);
 
  com::PtrCommunicationFactory _communicationFactory;
 
 
  com::PtrCommunication _communication;
 
  struct Mapping {
    int                 remoteRank;
    std::vector<int>    indices;
    com::PtrRequest     request;
    std::vector<double> recvBuffer;
  };
 
  std::vector<Mapping> _mappings;
 
  struct ConnectionData {
    int             remoteRank;
    com::PtrRequest request;
  };
 
  std::vector<ConnectionData> _connectionDataVector;
 
  bool _isConnected = false;
 
  std::list<std::pair<std::shared_ptr<com::Request>,
                      std::shared_ptr<std::vector<double>>>>
      bufferedRequests;
};
} // namespace m2n
} // namespace precice