STDStackMap.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 "tarch/multicore/Lock.h"
 
#include <map>
 
 
namespace peano4 {
  namespace maps {
    template <typename T>
    class STDStackMap;
  }
}
 
 
template <typename T>
class peano4::maps::STDStackMap {
  private:
    static tarch::logging::Log  _log;
 
    std::map< StackKey, T* >  _data;
 
    tarch::multicore::BooleanSemaphore                      _semaphore;
 
    void createStack(const StackKey& key);
  public:
    ~STDStackMap();
 
    bool empty(int treeId, int stackId) const;
 
    T* getForPush(int treeId, int stackId);
    T* getForPush(const StackKey& key);
 
    T* getForPop(int treeId, int stackId);
    T* getForPop(const StackKey& key);
 
    void clear();
 
    void clear(int spacetree);
 
    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;
};
 
 
#include "tarch/multicore/Lock.h"
 
 
template <typename T>
tarch::logging::Log  peano4::maps::STDStackMap<T>::_log( "peano4::maps::STDStackMap<T>" );
 
 
template <typename T>
void peano4::maps::STDStackMap<T>::createStack(const StackKey& key) {
  if ( _data.count( key )==0 ) {
    _data.insert(
      std::pair< StackKey, T* >(
        key,
        new T()
      )
    );
  }
}
 
 
template <typename T>
bool peano4::maps::STDStackMap<T>::empty(int treeId, int stackId) const {
  return _data.count( StackKey(treeId,stackId) )==0
      or _data.at( StackKey(treeId,stackId) )->empty();
}
 
 
template <typename T>
T* peano4::maps::STDStackMap<T>::getForPush(int treeId, int stackId) {
  return getForPush( StackKey(treeId,stackId) );
}
 
 
template <typename T>
T* peano4::maps::STDStackMap<T>::getForPush(const StackKey& key) {
  tarch::multicore::Lock lock(_semaphore);
  createStack(key);
  return _data[key];
}
 
 
template <typename T>
T* peano4::maps::STDStackMap<T>::getForPop(int treeId, int stackId) {
  return getForPop( StackKey(treeId,stackId) );
}
 
 
template <typename T>
T* peano4::maps::STDStackMap<T>::getForPop(const StackKey& key) {
  tarch::multicore::Lock lock(_semaphore);
  assertion( _data.count(key)==1 );
  return _data.at( key );
}
 
 
template <typename T>
std::string peano4::maps::STDStackMap<T>::toString() const {
  std::ostringstream msg;
  msg << "(" << _data.size();
  for (auto& p: _data) {
    msg << ","
        << p.first.first << "x" << p.first.second << ":" << p.second->size();
  }
  msg << ")";
  return msg.str();
}
 
 
template <typename T>
std::set<peano4::maps::StackKey>  peano4::maps::STDStackMap<T>::getKeys() {
  tarch::multicore::Lock lock(_semaphore);
  std::set<peano4::maps::StackKey> result;
  for (auto& p: _data) {
    result.insert(p.first);
  }
  return result;
}
 
 
template <typename T>
bool peano4::maps::STDStackMap<T>::holdsStack(int treeId, int stackId) const {
  return holdsStack( StackKey(treeId,stackId) );
}
 
 
template <typename T>
bool peano4::maps::STDStackMap<T>::holdsStack(const StackKey& key) const {
  return _data.count(key)==1;
}
 
 
template <typename T>
void peano4::maps::STDStackMap<T>::clear() {
  for (auto& p: _data) {
    delete p.second;
  }
 
  _data.clear();
}
 
 
template <typename T>
peano4::maps::STDStackMap<T>::~STDStackMap() {
  assertionMsg( _data.empty(), "forgot to call clear()" );
}
 
 
template <typename T>
void peano4::maps::STDStackMap<T>::garbageCollection(int spacetree) {
  const int localTreeId = peano4::parallel::Node::getInstance().getLocalTreeId(spacetree);
  for (auto& p: _data) {
    bool isCorrectOwner        = p.first.first==localTreeId;
    bool isEmptyTemporaryStack = isCorrectOwner
        and
        p.second->empty()
        and
        not peano4::parallel::Node::isStorageStackNumber(p.first.second);
 
 
    if ( isEmptyTemporaryStack ) {
      logDebug( "garbageCollection(...)", "remove stack " << p.first.first << "x" << p.first.second << ": " << p.second->toString() );
      delete p.second;
      p.second = new T();
      }
  }
}
 
 
template <typename T>
void peano4::maps::STDStackMap<T>::clear(int spacetree) {
  const int localTreeId = peano4::parallel::Node::getInstance().getLocalTreeId(spacetree);
  for (auto& p: _data) {
    if (
      p.first.first==localTreeId
    ) {
      logDebug( "garbageCollection(...)", "remove stack " << p.first.first << "x" << p.first.second << ": " << p.second->toString() );
      delete p.second;
      p.second = new T();
    }
  }
}