SpacetreeSet.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 "tarch/logging/Log.h"
 
#include "tarch/services/Service.h"
 
#include "tarch/multicore/Task.h"
#include "tarch/multicore/BooleanSemaphore.h"
#include "tarch/multicore/BooleanSemaphore.h"
 
#include "peano4/maps/maps.h"
#include "peano4/grid/grid.h"
#include "peano4/grid/GridStatistics.h"
 
#include "TreeManagementMessage.h"
 
#include <list>
#include <map>
#include <set>
 
namespace peano4 {
  namespace grid {
    class Spacetree;
    class TraversalObserver;
    struct GridStatistics;
    struct AutomatonState;
  }
 
  namespace parallel {
    class SpacetreeSet;
  }
}
 
class peano4::parallel::SpacetreeSet: public tarch::services::Service {
  private:
    friend class peano4::grid::Spacetree;
 
    static SpacetreeSet  _singleton;
 
    std::vector<peano4::parallel::TreeManagementMessage>   _unansweredMessages;
 
    class TraverseTask: public tarch::multicore::Task {
      private:
        peano4::grid::Spacetree&          _spacetree;
        SpacetreeSet&                     _spacetreeSet;
        peano4::grid::TraversalObserver&  _observer;
        const bool                        _invertTreeTraversalDirectionBeforeWeStart;
 
      public:
        TraverseTask( peano4::grid::Spacetree&  tree, SpacetreeSet& set, peano4::grid::TraversalObserver&  observer, bool invertTreeTraversalDirectionBeforeWeStart );
 
        virtual void run() override;
    };
 
  public:
    template <class Container>
    static void exchangeAllHorizontalDataExchangeStacks( Container& stackContainer, int spacetreeId, bool symmetricDataCardinality );
 
    template <class Container>
    static void exchangeAllPeriodicBoundaryDataStacks( Container& stackContainer, int spacetreeId );
 
    template <class Container>
    static void exchangeAllVerticalDataExchangeStacks(
      Container& stackContainer,
      int spacetreeId, int parentId
    );
 
    template <class Container>
    static void deleteAllStacks(
      Container& stackContainer,
      int spacetreeId
    );
 
    template <class Container>
    static void finishAllOutstandingSendsAndReceives( Container& stackContainer, int spacetreeId );
 
    template <class Container>
    static void streamDataFromSplittingTreeToNewTree( Container& stackContainer, int master, int worker );
 
    template <class Container>
    static void streamDataFromJoiningTreeToMasterTree( Container& stackContainer, int master, int worker );
 
  private:
    static tarch::logging::Log _log;
 
    static tarch::multicore::BooleanSemaphore                      _semaphore;
 
    enum class SpacetreeSetState {
      Waiting,
      TraverseTreesAndExchangeData
    };
 
    static std::string toString( SpacetreeSetState state );
 
    int     _requestMessageTag;
 
    int     _answerMessageTag;
 
    std::list< peano4::grid::Spacetree >  _spacetrees;
 
    peano4::grid::GridStatistics          _gridStatistics;
 
    peano4::grid::GridStatistics  sumUpLocalGridStatistics() const;
 
    SpacetreeSetState                     _state;
 
    std::map< int, peano4::grid::TraversalObserver* >    _clonedObserver;
 
    peano4::grid::Spacetree& getSpacetree(int id);
 
    const peano4::grid::Spacetree& getSpacetree(int id) const;
 
    int getAnswerTag( int targetSpacetreeId ) const;
 
    void exchangeHorizontalDataBetweenTrees(peano4::grid::TraversalObserver&  observer);
    void exchangeVerticalDataBetweenTrees(peano4::grid::TraversalObserver&  observer);
 
    void deleteAllStacks( peano4::grid::TraversalObserver&  observer, int spacetreeId );
 
    void streamDataFromSplittingTreesToNewTrees(peano4::grid::TraversalObserver&  observer);
 
    void createNewTrees();
 
    void deleteClonedObservers();
 
    void addSpacetree( int masterId, int newTreeId );
 
    void streamLocalVertexInformationToMasterThroughVerticalStacks(
      int spacetreeId, int parentId,
      const std::set<int>& joiningIds
    );
 
    void cleanUpTrees(peano4::grid::TraversalObserver&  observer);
 
    std::set<int>                 getLocalTreesMergingWithWorkers() const;
 
    void createObserverCloneIfRequired(peano4::grid::TraversalObserver& observer, int treeId);
 
    SpacetreeSet();
    SpacetreeSet(const SpacetreeSet& ) = delete;
    SpacetreeSet& operator=(const SpacetreeSet& ) = delete;
 
  public:
    ~SpacetreeSet();
 
    static SpacetreeSet& getInstance();
 
 
    void answerQuestions();
 
    virtual void receiveDanglingMessages() override;
 
    void init(
      const tarch::la::Vector<Dimensions,double>&  offset,
      const tarch::la::Vector<Dimensions,double>&  width,
      const std::bitset<Dimensions>&               periodicBC = 0
    );
 
    virtual void shutdown() override;
 
    void traverse(peano4::grid::TraversalObserver& observer);
 
    peano4::grid::GridStatistics  getGridStatistics() const;
 
    peano4::grid::GridStatistics  getGridStatistics(int treeId) const;
 
    bool split(int treeId, const peano4::SplitInstruction& instruction, int targetRank);
 
    bool isLocalSpacetree(int treeId) const;
 
    std::set<int> getLocalSpacetrees() const;
};
 
#include "SpacetreeSet.cpph"