HierarchicalStackMap.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 "maps.h"
 
#include "peano4/parallel/Node.h"
 
#include "tarch/multicore/Lock.h"
 
#include <map>
 
 
 
namespace peano4 {
  namespace maps {
    template <typename T>
    class HierarchicalStackMap;
  }
}
 
 

template <typename T>
class peano4::maps::HierarchicalStackMap {
  private:
    struct TreeData {
      std::map< int, T* >                 _stackNumberToData;
    };

    std::vector< TreeData >            _data;

    void createStack(int localTreeNumber, int stackNumber);
 
  public:
    HierarchicalStackMap();
    ~HierarchicalStackMap();
 
    bool empty(int treeId, int stackId) const;

    void clear();
 
    void clear(int spacetree);

    T* getForPush(int treeId, int stackId);
    T* getForPush(const StackKey& key);

    T* getForPop(int treeId, int stackId);
    T* getForPop(const StackKey& key);
 
    std::string toString() const;

    std::set<StackKey>  getKeys();

    void garbageCollection(int spacetree);

    bool holdsStack(int treeId, int stackId) const;
    bool holdsStack(const StackKey& key) const;
};
 
 
template <typename T>
void peano4::maps::HierarchicalStackMap<T>::createStack(int localTreeNumber, int stackNumber) {
  assertion(localTreeNumber>=0);
  assertion(localTreeNumber<static_cast<int>(_data.size()));
  if ( _data[localTreeNumber]._stackNumberToData.count(stackNumber)==0 ) {
    _data[localTreeNumber]._stackNumberToData.insert(
      std::pair< int, T* >(
        stackNumber,
        new T()
      )
    );
  }
}
 
 
template <typename T>
bool peano4::maps::HierarchicalStackMap<T>::empty(int treeId, int stackId) const {
  const int localTreeId = peano4::parallel::Node::getInstance().getLocalTreeId(treeId);
  assertion3(localTreeId>=0,localTreeId,treeId,stackId);
  assertion4(localTreeId<_data.size(),localTreeId,_data.size(),treeId,stackId);
  return _data[localTreeId]._stackNumberToData.count(stackId)==0
      or _data[localTreeId]._stackNumberToData.at(stackId)->empty();
}
 
 
template <typename T>
T* peano4::maps::HierarchicalStackMap<T>::getForPush(int treeId, int stackId) {
  return getForPush( StackKey(treeId,stackId) );
}
 
 
template <typename T>
bool peano4::maps::HierarchicalStackMap<T>::holdsStack(int treeId, int stackId) const {
  return holdsStack( StackKey(treeId,stackId) );
}
 
 
template <typename T>
bool peano4::maps::HierarchicalStackMap<T>::holdsStack(const StackKey& key) const {
  const int localTreeId = peano4::parallel::Node::getInstance().getLocalTreeId(key.first);
  assertion3(localTreeId>=0,localTreeId,key.first,key.second);
  assertion4(localTreeId<static_cast<int>(_data.size()),localTreeId,_data.size(),key.first,key.second);
  return _data[localTreeId]._stackNumberToData.count(key.second)==1;
}
 
 
template <typename T>
T* peano4::maps::HierarchicalStackMap<T>::getForPush(const StackKey& key) {
  const int localTreeId = peano4::parallel::Node::getInstance().getLocalTreeId(key.first);
  assertion3(localTreeId>=0,localTreeId,key.first,key.second);
  assertion4(localTreeId<static_cast<int>(_data.size()),localTreeId,_data.size(),key.first,key.second);
  createStack(localTreeId,key.second);
  assertion4( _data[localTreeId]._stackNumberToData[key.second] != nullptr, localTreeId, key.first, key.second, tarch::mpi::Rank::getInstance().getRank() );
  return _data[localTreeId]._stackNumberToData[key.second];
}
 
 
template <typename T>
T* peano4::maps::HierarchicalStackMap<T>::getForPop(int treeId, int stackId) {
  return getForPop( StackKey(treeId,stackId) );
}
 
 
template <typename T>
T* peano4::maps::HierarchicalStackMap<T>::getForPop(const StackKey& key) {
  const int localTreeId = peano4::parallel::Node::getInstance().getLocalTreeId(key.first);
  assertion3(localTreeId>=0,localTreeId,key.first,key.second);
  assertion4(localTreeId<static_cast<int>(_data.size()),localTreeId,_data.size(),key.first,key.second);
  assertion4(_data[localTreeId]._stackNumberToData.count(key.second)==1,localTreeId,_data.size(),key.first,key.second);
  assertion3(key.second>=0,localTreeId,key.first,key.second);
  return _data[localTreeId]._stackNumberToData.at(key.second);
}
 
 
template <typename T>
std::string peano4::maps::HierarchicalStackMap<T>::toString() const {
  std::string result = "(" + std::to_string( _data.size() );
/*
  for (auto& p: _data) {
    result += ",";
    result += std::to_string(p.first.first) + "x" + std::to_string(p.first.second) + ":" + std::to_string(p.second->size());
  }
*/
  result += ")";
  return result;
}
 
 
template <typename T>
std::set<peano4::maps::StackKey>  peano4::maps::HierarchicalStackMap<T>::getKeys() {
  std::set<peano4::maps::StackKey> result;
  for (int i = 0; i < static_cast<int>(_data.size()); i++) {
    for (auto& pp: _data[i]._stackNumberToData) {
      result.insert( peano4::maps::StackKey( peano4::parallel::Node::getInstance().getGlobalTreeId(i),pp.first) );
    }
  }
  return result;
}
 
 
template <typename T>
peano4::maps::HierarchicalStackMap<T>::~HierarchicalStackMap() {
  for (auto& p: _data) {
    for (auto& pp: p._stackNumberToData) {
      delete pp.second;
    }
  }
}
 
 
template <typename T>
peano4::maps::HierarchicalStackMap<T>::HierarchicalStackMap():
  _data(peano4::parallel::Node::MaxSpacetreesPerRank) {
}
 
 
template <typename T>
void peano4::maps::HierarchicalStackMap<T>::garbageCollection(int spacetree) {
  const int localTreeId = peano4::parallel::Node::getInstance().getLocalTreeId(spacetree);
  if (static_cast<int>(_data.size()) > localTreeId) {
    for (auto& p: _data[localTreeId]._stackNumberToData) {
      if (
        p.second->empty()
        and
        not peano4::parallel::Node::isStorageStackNumber(p.first)
      ) {
        delete p.second;
        p.second = new T();
      }
    }
  }
}
 
 
template <typename T>
void peano4::maps::HierarchicalStackMap<T>::clear() {
  for (auto& p: _data) {
    for (auto& pp: p._stackNumberToData) {
      if (pp.second->empty()) {
        delete pp.second;
        pp.second = new T();
      }
    }
  }
}
 
 
template <typename T>
void peano4::maps::HierarchicalStackMap<T>::clear(int spacetree) {
  const int localTreeId = peano4::parallel::Node::getInstance().getLocalTreeId(spacetree);
  if (static_cast<int>(_data.size()) > localTreeId) {
    for (auto& p: _data[localTreeId]._stackNumberToData) {
      delete p.second;
      p.second = new T();
    }
  }
}