STDVectorStack.h

Go to the documentation of this file.

// This file is part of the Peano project. For conditions of distribution and
// use, please see the copyright notice at www.peano-framework.org
#pragma once
 
#include <vector>
#include <algorithm>
 
#include "stacks.h"
 
#include "peano4/parallel/Node.h"
#include "peano4/grid/GridVertex.h"
#include "peano4/grid/TraversalObserver.h"
 
#include "tarch/logging/Log.h"
#include "tarch/Assertions.h"
#include "tarch/mpi/Rank.h"
#include "tarch/multicore/Task.h"
 
namespace peano4 {
  namespace stacks {
    template <class T>
    class STDVectorStack;
 
    typedef STDVectorStack< peano4::grid::GridVertex > GridVertexStack;
 
    #if defined(Parallel)
    template <class T>
    MPI_Datatype translateContextIntoDatatype( peano4::grid::TraversalObserver::SendReceiveContext context );
    #endif
  }
}
 
template <class T>
class peano4::stacks::STDVectorStack {
  protected:
    static tarch::logging::Log _log;
 
    std::vector< T >   _data;
 
    int                _currentElement;
 
    IOMode              _ioMode;
    int                 _ioRank;
    int                 _ioTag;
    #ifdef Parallel
    MPI_Request*        _ioMPIRequest;
    #endif
 
  public:
    STDVectorStack():
      _data(),
      _currentElement(0),
      _ioMode(IOMode::None),
      _ioRank(-1),
      _ioTag(-1)
      #ifdef Parallel
      ,
      _ioMPIRequest(nullptr)
      #endif
    {}
 
    ~STDVectorStack() = default;
 
    STDVectorStack( [[maybe_unused]] const STDVectorStack<T>& stack ):
      _data(),
      _currentElement(0),
      _ioMode(IOMode::None)
      #ifdef Parallel
        ,
      _ioMPIRequest(nullptr)
      #endif
    {
      assertionMsg( stack._currentElement==0, "may not copy non-empty stack" );
      #ifdef Parallel
      assertionMsg( stack._ioMPIRequest==nullptr, "may not copy sending/receiving stack" );
      #endif
    }
 
    STDVectorStack& operator=( [[maybe_unused]] const STDVectorStack<T>& stack ) {
      assertionEquals( stack._currentElement, 0 );
      assertionEquals( _currentElement, 0 );
      assertion( _data.empty() );
    }
 
    void  clone( const STDVectorStack<T>&  data ) {
      assertionEquals1( _currentElement, 0, toString() );
      _data.clear();
      _currentElement = data._currentElement;
      _data.resize(_currentElement, T(T::ObjectConstruction::NoData));
      for (int n = 0; n<_currentElement; n++) {
        _data[n] = data._data[n];
      }
    }
 
    class PopBlockStackView {
      protected:
        friend class peano4::stacks::STDVectorStack<T>;
 
        const int                           _size;
        const int                           _baseElement;
        peano4::stacks::STDVectorStack<T>*  _stack;
 
        PopBlockStackView(int size, int base, peano4::stacks::STDVectorStack<T>* stack):
          _size(size),
          _baseElement(base),
          _stack(stack) {
        }
 
      public:
        int size() const {
          return _size;
        }
 
        const T& get(int index) const {
          assertion2( index>=0, index, _size );
          assertion2( index<_size, index, _size );
          return _stack->_data[_baseElement+index];
        }
 
        T& get(int index) {
          assertion2( index>=0, index, _size );
          assertion2( index<_size, index, _size );
          return _stack->_data[_baseElement+index];
        }
 
        std::string toString() const {
          std::ostringstream msg;
          msg << "(size=" << _size
              << ",baseElement=" << _baseElement
              << ")";
          return msg.str();
        }
    };
 
    class PushBlockStackView {
      protected:
        friend class peano4::stacks::STDVectorStack<T>;
 
        PushBlockStackView(int size, int base, peano4::stacks::STDVectorStack<T>* stack):
          _size(size),
          _baseElement(base),
          _stack(stack) {
        }
 
        const int                           _size;
        const int                           _baseElement;
        peano4::stacks::STDVectorStack<T>*  _stack;
 
      public:
        inline int size() const {
          return _size;
        }
 
        inline T* set(int index, const T& value) {
          assertion2( index>=0, index, _size );
          assertion2( index<_size, index, _size );
          _stack->_data[_baseElement+index] = value;
          return &(_stack->_data[_baseElement+index]);
        }
 
        inline const T& get(int index) const {
          assertion2( index>=0, index, _size );
          assertion2( index<_size, index, _size );
          return _stack->_data[_baseElement+index];
        }
 
        inline T& get(int index) {
          assertion2( index>=0, index, _size );
          assertion2( index<_size, index, _size );
          return _stack->_data[_baseElement+index];
        }
 
        inline std::string toString() const {
          std::ostringstream msg;
          msg << "(size=" << _size
              << ",baseElement=" << _baseElement
              << ")";
          return msg.str();
        }
    };
 
    T pop() {
      assertion1(_currentElement>0,_currentElement);
      _currentElement--;
      return std::move( _data[_currentElement] );
    }
 
    T& top(int shift=0) {
      assertion1(shift>=0,shift);
      assertion2(_currentElement>shift, _currentElement, shift);
      return _data[_currentElement-1-shift];
    }
 
    const T& top(int shift=0) const {
      assertion1(shift>=0,shift);
      assertion2(_currentElement>shift, _currentElement, shift);
      return _data[_currentElement-1-shift];
    }
 
    void push( const T& element ) {
      assertion( _currentElement <= static_cast<int>(_data.size()) );
      if (_currentElement >= static_cast<int>(_data.size()) ) {
        assertion(_currentElement - static_cast<int>(_data.size()) <= 1 );
        _data.push_back( element );
      } else {
        _data[_currentElement] = element;
      }
      _currentElement++;
    }
 
    PopBlockStackView  popBlock(int numberOfElements) {
      _currentElement-=numberOfElements;
      assertion( _currentElement>=0 );
 
      PopBlockStackView result(numberOfElements, _currentElement, this);
      return result;
    }
 
    PushBlockStackView pushBlock(int numberOfElements) {
      PushBlockStackView result(numberOfElements, _currentElement, this);
 
      _currentElement+=numberOfElements;
 
      if (static_cast<int>(_data.size())<=_currentElement) {
        _data.resize(_currentElement, T(T::ObjectConstruction::NoData));
        assertion(static_cast<int>(_data.size())>=_currentElement);
      }
 
      return result;
    }
 
    int size() const {
      return _currentElement;
    }
 
    bool empty() const {
      return _currentElement==0;
    }
 
    void clear() {
      _currentElement = 0;
    }
 
    void startSend(
      [[maybe_unused]] peano4::grid::TraversalObserver::SendReceiveContext context,
      [[maybe_unused]] int rank,
      [[maybe_unused]] int tag,
      [[maybe_unused]] MPI_Comm comm
    ) {
      #ifdef Parallel
      assertion( _ioMode==IOMode::None );
      assertion( _ioMPIRequest==nullptr );
      _ioMode = IOMode::MPISend;
      _ioTag  = tag;
      _ioRank = rank;
 
      logDebug( "startSend(int,int,bool)", toString());
 
      _ioMPIRequest = new MPI_Request;
      int result = MPI_Isend(
        _data.data(),
        _currentElement,
        translateContextIntoDatatype<T>( context ),
        _ioRank, _ioTag, comm, _ioMPIRequest);
      if  (result!=MPI_SUCCESS) {
        logError( "startSend(int,int,bool)", "was not able to send to node " << rank << " on tag " << tag
          << ": " << tarch::mpi::MPIReturnValueToString(result)
        );
      }
      #endif
    }
 
    void startReceive(
      [[maybe_unused]] peano4::grid::TraversalObserver::SendReceiveContext context,
      [[maybe_unused]] int rank,
      [[maybe_unused]] int tag,
      [[maybe_unused]] MPI_Comm comm,
      [[maybe_unused]] int numberOfElements
    ) {
      #ifdef Parallel
      assertion3( _ioMode==IOMode::None, rank, tag, numberOfElements );
      assertion3( numberOfElements>0, rank, tag, numberOfElements );
 
      _ioMode = IOMode::MPIReceive;
      _ioTag  = tag;
      _ioRank = rank;
 
      _data.resize(numberOfElements, T(T::ObjectConstruction::NoData));
      _currentElement = numberOfElements;
      assertionEquals( _data.size(), numberOfElements );
 
      assertion( _ioMPIRequest == nullptr );
      _ioMPIRequest = new MPI_Request;
 
      int result = MPI_Irecv(
        _data.data(),
        _data.size(),
        translateContextIntoDatatype<T>( context ),
        _ioRank, _ioTag, comm, _ioMPIRequest);
      if  (result!=MPI_SUCCESS) {
        logError( "startReceive(int,int,int)", "was not able to receive " << numberOfElements << " values from node " << rank << " on tag " << tag
           << ": " << tarch::mpi::MPIReturnValueToString(result)
        );
      }
 
      logDebug( "startReceive()", toString() );
      #endif
    }
 
    bool tryToFinishSendOrReceive() {
      #ifdef Parallel
      logTraceInWith4Arguments( "tryToFinishSendOrReceive()", ::toString(_ioMode), size(), _ioRank,_ioTag );
      bool result = true;
      if ( _ioMode==IOMode::MPISend or _ioMode==IOMode::MPIReceive ) {
        assertion( _ioMPIRequest!=nullptr );
 
        int          flag = 0;
        MPI_Test( _ioMPIRequest, &flag, MPI_STATUS_IGNORE );
        if (flag) {
          result = true;
          logDebug( "tryToFinishSendOrReceive()", "send/receive complete, free MPI request: " << toString() );
          delete _ioMPIRequest;
          _ioMPIRequest = nullptr;
          if (_ioMode==IOMode::MPISend ) {
            clear();
          }
          _ioMode = IOMode::None;
        } else {
          result = false;
        }
      }
      logTraceOutWith1Argument( "tryToFinishSendOrReceive()", result );
      return result;
      #else
      return true;
      #endif
    }
 
    int sendingOrReceiving() const {
      return _ioMode==IOMode::None ? -1 : _ioRank;
    }
 
    void reverse() {
      std::reverse(std::begin(_data), std::end(_data));
    }
 
    std::string toString() const {
      std::ostringstream msg;
      msg << "(size=" << size()
          << ",current-element=" << _currentElement
          << ",io-mode=" << ::toString( _ioMode )
          << ",rank=" << _ioRank
          << ",tag=" << _ioTag
          << ")";
      return msg.str();
    }
};
 
template <class T>
tarch::logging::Log peano4::stacks::STDVectorStack<T>::_log( "peano4::stacks::STDVectorStack<T>" );
 
template <>
void peano4::stacks::STDVectorStack<double>::startSend(peano4::grid::TraversalObserver::SendReceiveContext, int rank, int tag, MPI_Comm comm);
 
template <>
void peano4::stacks::STDVectorStack<double>::startReceive(peano4::grid::TraversalObserver::SendReceiveContext, int rank, int tag, MPI_Comm comm, int numberOfElements);
 
#if defined(Parallel)
template <class T>
MPI_Datatype peano4::stacks::translateContextIntoDatatype( peano4::grid::TraversalObserver::SendReceiveContext context ) {
   switch (context) {
     case peano4::grid::TraversalObserver::SendReceiveContext::BoundaryExchange:
       return T::getBoundaryExchangeDatatype();
     case peano4::grid::TraversalObserver::SendReceiveContext::MultiscaleExchange:
       return T::getMultiscaleDataExchangeDatatype();
     case peano4::grid::TraversalObserver::SendReceiveContext::ForkDomain:
       return T::getForkDatatype();
     case peano4::grid::TraversalObserver::SendReceiveContext::JoinDomain:
       return T::getJoinDatatype();
     case peano4::grid::TraversalObserver::SendReceiveContext::PeriodicBoundaryDataSwap:
       assertionMsg(false, "periodic boundary data is never exchanged via MPI" );
       return T::getGlobalCommunciationDatatype();
   }
   assertionMsg(false, "no valid case statement found. This may not happen" );
   return T::getGlobalCommunciationDatatype();
}
#endif