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 collective operations
       7              : 
       8              : template <class Cell_T, unsigned int dim>
       9              : template <class Container_T1, class Container_T2>
      10              : void coupling::sendrecv::FromMD2Macro<Cell_T, dim>::reduceFromMD2Macro(std::vector<coupling::sendrecv::DataExchangeFromMD2Macro<dim>*>& dataExchanges,
      11              :                                                                        const Container_T1& src, const Container_T2& dst) {
      12              :   const unsigned int rank = IDXS.getRank();
      13              : 
      14              :   // empty send and receive buffers
      15              :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::deleteBuffers();
      16              : 
      17              :   for (unsigned int i = 0; i < dataExchanges.size(); ++i) {
      18              :     if (nullptr == dataExchanges[i])
      19              :       continue;
      20              :     // fill the reduce buffers (expands the reduce buffer)
      21              :     writeToReduceBuffer(*dataExchanges[i], src);
      22              :     // allocate the reduce buffers (additional)
      23              :     allocateReduceBufferForReceiving(*dataExchanges[i], dst);
      24              :   }
      25              : 
      26              :   // allocate all requests -> needs to be called AFTER all buffers are filled
      27              :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::allocateReduceRequests(rank);
      28              : 
      29              :   // trigger MPI reduce
      30              :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::triggerReduce(rank);
      31              : 
      32              :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::waitAllCollectiveOperations();
      33              : 
      34              :   for (unsigned int i = 0; i < dataExchanges.size(); ++i) {
      35              :     if (nullptr == dataExchanges[i])
      36              :       continue;
      37              :     readFromReduceBuffer(*dataExchanges[i], dst);
      38              :   }
      39              : }
      40              : 
      41              : template <class Cell_T, unsigned int dim>
      42              : void coupling::sendrecv::FromMD2Macro<Cell_T, dim>::writeToReduceBuffer(coupling::sendrecv::DataExchangeFromMD2Macro<dim>& dataExchange,
      43              :                                                                         const Local_Container_T& cells) {
      44              :   for (auto idx : I10())
      45              :     coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::writeToReduceBuffer(dataExchange, cells[idx], idx);
      46              : }
      47              : 
      48              : template <class Cell_T, unsigned int dim>
      49              : template <class Container_T>
      50              : void coupling::sendrecv::FromMD2Macro<Cell_T, dim>::allocateReduceBufferForReceiving(coupling::sendrecv::DataExchangeFromMD2Macro<dim>& dataExchange,
      51              :                                                                                      const Container_T& cells) {
      52              :   I01* idx;
      53              :   Cell_T* cell;
      54              :   for (auto pair : cells) {
      55              :     std::tie(cell, idx) = pair;
      56              :     coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::allocateReduceBufferForReceiving(dataExchange, idx);
      57              :   }
      58              : }
      59              : 
      60              : template <class Cell_T, unsigned int dim>
      61              : template <class Container_T>
      62              : void coupling::sendrecv::FromMD2Macro<Cell_T, dim>::readFromReduceBuffer(coupling::sendrecv::DataExchangeFromMD2Macro<dim>& dataExchange,
      63              :                                                                          const Container_T& cells) {
      64              :   I01* idx;
      65              :   Cell_T* cell;
      66              :   for (auto pair : cells) {
      67              :     std::tie(cell, idx) = pair;
      68              :     coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::readFromReduceBuffer(dataExchange, cell, idx);
      69              :   }
      70              : }
      71              : 
      72              : #pragma endregion // collective operations
      73              : 
      74              : #pragma region sequential operations
      75              : 
      76              : template <class Cell_T, unsigned int dim>
      77            0 : void coupling::sendrecv::FromMD2Macro<Cell_T, dim>::sendFromMD2Macro(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Local_Container_T& src,
      78              :                                                                      const Macro_Container_T& dst) {
      79            0 :   sendFromMD2MacroNonBlocking(dataExchange, src, dst);
      80            0 :   wait4SendFromMD2Macro(dataExchange, dst);
      81            0 : }
      82              : 
      83              : template <class Cell_T, unsigned int dim>
      84            0 : void coupling::sendrecv::FromMD2Macro<Cell_T, dim>::sendFromMD2MacroNonBlocking(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange,
      85              :                                                                                 const Local_Container_T& src, const Macro_Container_T& dst) {
      86              :   // empty send and receive buffers
      87            0 :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::deleteBuffers();
      88              : 
      89              :   // allocate the receive buffers and trigger the MPI-recv
      90            0 :   allocateReceiveBuffers(dataExchange, dst);
      91              :   // fill the send buffers
      92            0 :   writeToSendBuffer(dataExchange, src);
      93              : 
      94              :   // allocate all requests -> needs to be called AFTER all buffers are filled
      95            0 :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::allocateRequests();
      96              : 
      97              :   // trigger MPI recv/send
      98            0 :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::triggerReceiving(dataExchange);
      99            0 :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::triggerSending(dataExchange);
     100            0 : }
     101              : 
     102              : template <class Cell_T, unsigned int dim>
     103            0 : void coupling::sendrecv::FromMD2Macro<Cell_T, dim>::allocateReceiveBuffers(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange,
     104              :                                                                            const Macro_Container_T& cells) {
     105            0 :   I01 idx;
     106              :   Cell_T* cell;
     107            0 :   for (auto pair : cells) {
     108            0 :     std::tie(cell, idx) = pair;
     109            0 :     coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::allocateReceiveBuffers(dataExchange, idx);
     110              :   }
     111            0 : }
     112              : 
     113              : template <class Cell_T, unsigned int dim>
     114            0 : void coupling::sendrecv::FromMD2Macro<Cell_T, dim>::writeToSendBuffer(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange,
     115              :                                                                       const Local_Container_T& cells) {
     116            0 :   coupling::datastructures::CellContainer<I10, dim> container;
     117            0 :   for (auto idx : I10())
     118            0 :     container << cells[idx];
     119            0 :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::writeToSendBuffer(dataExchange, container);
     120            0 : }
     121              : 
     122              : template <class Cell_T, unsigned int dim>
     123            0 : void coupling::sendrecv::FromMD2Macro<Cell_T, dim>::wait4SendFromMD2Macro(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange,
     124              :                                                                           const Macro_Container_T& cells) {
     125              :   // wait for all send- and receive operations to complete
     126            0 :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::waitAllOperations();
     127              : 
     128              :   // fill information from receive buffers into the coupling cells
     129            0 :   readFromReceiveBuffer(dataExchange, cells);
     130            0 : }
     131              : 
     132              : template <class Cell_T, unsigned int dim>
     133            0 : void coupling::sendrecv::FromMD2Macro<Cell_T, dim>::readFromReceiveBuffer(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange,
     134              :                                                                           const Macro_Container_T& cells) {
     135            0 :   coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>::readFromReceiveBuffer(dataExchange, cells);
     136            0 : }
     137              : 
     138              : #pragma endregion // sequential operations