Line data    Source code

       1             : // Copyright (C) 2015 Technische Universitaet Muenchen
       2             : // This file is part of the Mamico project. For conditions of distribution
       3             : // and use, please see the copyright notice in Mamico's main folder, or at
       4             : // www5.in.tum.de/mamico
       5             : 
       6             : #pragma region sequential operations
       7             : 
       8             : template <class Cell_T, unsigned int dim>
       9             : template <class Container_T>
      10           0 : void coupling::sendrecv::FromMacro2MD<Cell_T, dim>::sendFromMacro2MD(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Local_Container_T& dst,
      11             :                                                                      const Container_T& src) {
      12             :   // send data
      13           0 :   sendFromMacro2MDNonBlocking(dataExchange, src);
      14             :   // wait for MPI calls to be finished and fill coupling cells from Mamico
      15           0 :   wait4SendFromMacro2MD(dataExchange, dst);
      16           0 : }
      17             : 
      18             : template <class Cell_T, unsigned int dim>
      19             : template <class Container_T>
      20           0 : void coupling::sendrecv::FromMacro2MD<Cell_T, dim>::sendFromMacro2MDNonBlocking(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange,
      21             :                                                                                 const Container_T& cells) {
      22             :   // empty send and receive buffers
      23           0 :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::deleteBuffers();
      24             : 
      25             :   // allocate the receive buffers and trigger the MPI-recv
      26           0 :   allocateReceiveBuffers(dataExchange);
      27             :   // fill the send buffers
      28           0 :   writeToSendBuffer(dataExchange, cells);
      29             : 
      30             :   // allocate all requests -> needs to be called AFTER all buffers are filled
      31           0 :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::allocateRequests();
      32             : 
      33             :   // trigger MPI calls for send/recv
      34           0 :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::triggerReceiving(dataExchange);
      35           0 :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::triggerSending(dataExchange);
      36           0 : }
      37             : 
      38             : template <class Cell_T, unsigned int dim>
      39           0 : void coupling::sendrecv::FromMacro2MD<Cell_T, dim>::allocateReceiveBuffers(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange) {
      40           0 :   for (auto idx : I02())
      41           0 :     coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::allocateReceiveBuffers(dataExchange, idx);
      42           0 : }
      43             : 
      44             : template <class Cell_T, unsigned int dim>
      45             : template <class Container_T>
      46           0 : void coupling::sendrecv::FromMacro2MD<Cell_T, dim>::writeToSendBuffer(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Container_T& cells) {
      47           0 :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::writeToSendBuffer(dataExchange, cells);
      48           0 : }
      49             : 
      50             : template <class Cell_T, unsigned int dim>
      51           0 : void coupling::sendrecv::FromMacro2MD<Cell_T, dim>::wait4SendFromMacro2MD(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange,
      52             :                                                                           const Local_Container_T& cells) {
      53             :   // wait for all send- and receive operations to complete
      54           0 :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::waitAllOperations();
      55             : 
      56             :   // fill information from receive buffers into the coupling cells
      57           0 :   readFromReceiveBuffer(dataExchange, cells);
      58           0 : }
      59             : 
      60             : template <class Cell_T, unsigned int dim>
      61           0 : void coupling::sendrecv::FromMacro2MD<Cell_T, dim>::readFromReceiveBuffer(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange,
      62             :                                                                           const Local_Container_T& cells) {
      63           0 :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::readFromReceiveBuffer(dataExchange, cells);
      64           0 : }
      65             : 
      66             : #pragma endregion // sequential operations
      67             : 
      68             : #pragma region collective operations
      69             : template <class Cell_T, unsigned int dim>
      70             : template <class Container_T>
      71             : void coupling::sendrecv::FromMacro2MD<Cell_T, dim>::bcastFromMacro2MD(
      72             :     std::vector<coupling::sendrecv::DataExchangeFromMacro2MD<dim>*>& dataExchangeFromCouplingCellServices, const Container_T& src,
      73             :     std::vector<Local_Container_T> dst) {
      74             :   // empty send and receive buffers
      75             :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::deleteBuffers();
      76             : 
      77             :   const unsigned int rank = IDXS.getRank();
      78             : 
      79             :   for (auto& de : dataExchangeFromCouplingCellServices) {
      80             :     if (nullptr == de)
      81             :       continue;
      82             :     // TODO compute target ranks here and pass them in
      83             :     writeToSendBufferCollective(*de, src);
      84             :     allocateReceiveBuffersCollective(*de);
      85             :   }
      86             : 
      87             :   SendReceiveBuffer<Cell_T, dim>::allocateBcastRequests(rank);
      88             : 
      89             :   // SendReceiveBuffer<Cell_T,dim >::triggerReceivingCollective(dataExchange);
      90             :   SendReceiveBuffer<Cell_T, dim>::triggerBcasts(rank);
      91             : 
      92             :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::waitAllCollectiveOperations();
      93             : 
      94             :   for (unsigned int i = 0; i < dataExchangeFromCouplingCellServices.size(); ++i) {
      95             :     if (dst[i].empty())
      96             :       continue;
      97             :     if (nullptr == dataExchangeFromCouplingCellServices[i])
      98             :       continue;
      99             :     readFromCollectiveBuffer(*dataExchangeFromCouplingCellServices[i], dst[i]);
     100             :   }
     101             : }
     102             : 
     103             : template <class Cell_T, unsigned int dim>
     104             : template <class Container_T>
     105             : void coupling::sendrecv::FromMacro2MD<Cell_T, dim>::writeToSendBufferCollective(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange,
     106             :                                                                                 const Container_T& cells) {
     107             :   I01 idx;
     108             :   Cell_T* cell;
     109             :   for (auto pair : cells) {
     110             :     std::tie(cell, idx) = pair;
     111             :     coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::writeToBcastBuffer(dataExchange, cell, idx);
     112             :   }
     113             : }
     114             : 
     115             : template <class Cell_T, unsigned int dim>
     116             : void coupling::sendrecv::FromMacro2MD<Cell_T, dim>::allocateReceiveBuffersCollective(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange) {
     117             :   for (auto idx : I02())
     118             :     coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::allocateBcastBufferForReceiving(dataExchange, idx);
     119             : }
     120             : 
     121             : template <class Cell_T, unsigned int dim>
     122             : void coupling::sendrecv::FromMacro2MD<Cell_T, dim>::readFromCollectiveBuffer(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange,
     123             :                                                                              const Local_Container_T& cells) {
     124             :   I01 idx;
     125             :   Cell_T* cell;
     126             :   for (auto pair : cells) {
     127             :     std::tie(cell, idx) = pair;
     128             :     coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::readFromCollectiveBuffer(dataExchange, *cell, idx);
     129             :   }
     130             : }
     131             : 
     132             : #pragma endregion // collective operations