AuxVectorData.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include "AthContainers/AuxVectorData.h"
#include "AthContainersInterfaces/IConstAuxStore.h"
#include "AthContainersInterfaces/IAuxStore.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/exceptions.h"
#include "AthContainers/tools/error.h"
#include "CxxUtils/checker_macros.h"
#include <sstream>
 
 
namespace SG {
 

size_t AuxVectorData::s_minCacheLen = 1024;
 

const SG::auxid_set_t AuxVectorData::s_emptySet(0);
 

AuxVectorData::AuxVectorData()
  : m_store(0),
    m_constStore( 0 )
{
}
 

AuxVectorData::AuxVectorData (AuxVectorData&& rhs)
  : m_cache (std::move (rhs.m_cache)),
    m_constCache (std::move (rhs.m_constCache)),
    m_decorCache (std::move (rhs.m_decorCache)),
    m_spanCache (std::move (rhs.m_spanCache)),
    m_store (rhs.m_store),
    m_constStore (rhs.m_constStore),
    m_constStoreLink (std::move (rhs.m_constStoreLink))
{
  rhs.m_store = 0;
  rhs.m_constStore = 0;
  rhs.m_constStoreLink.clear();
}
 

AuxVectorData& AuxVectorData::operator= (AuxVectorData&& rhs)
{
  if (this != &rhs) {
    m_cache = std::move (rhs.m_cache);
    m_constCache = std::move (rhs.m_constCache);
    m_decorCache = std::move (rhs.m_decorCache);
    m_spanCache = std::move (rhs.m_spanCache);
    m_store = rhs.m_store;
    m_constStore = rhs.m_constStore;
    m_constStoreLink = rhs.m_constStoreLink;
 
    rhs.m_store = 0;
    rhs.m_constStore = 0;
    rhs.m_constStoreLink.clear();
  }
  return *this;
}
 

AuxVectorData::~AuxVectorData()
{
}
 

void AuxVectorData::setStore (const SG::IConstAuxStore* store)
{
  m_store = 0;
  m_constStore = store;
  m_constStoreLink.clear();
  clearCache();
}
 

void AuxVectorData::setStore (SG::IAuxStore* store)
{
  m_store = store;
  m_constStore = store;
  m_constStoreLink.clear();
  clearCache();
}
 

void AuxVectorData::setStore (const DataLink< SG::IConstAuxStore >& store)
{
  m_store = 0;
  m_constStore = 0;
  m_constStoreLink = store;
  clearCache();
}
 

bool AuxVectorData::setOption (auxid_t id, const AuxDataOption& option)
{
  if (id == null_auxid) return false;
  SG::IAuxStore* store = getStore();
  if (!store) return false;
  return store->setOption (id, option);
}
 

bool AuxVectorData::setOption (const std::string& name,
                               const AuxDataOption& option)
{
  auxid_t id = SG::AuxTypeRegistry::instance().findAuxID (name);
  return setOption (id, option);
}
 

bool AuxVectorData::setOption (const std::string& name,
                               const std::string& clsname,
                               const AuxDataOption& option)
{
  auxid_t id = SG::AuxTypeRegistry::instance().findAuxID (name, clsname);
  return setOption (id, option);
}
 

const SG::auxid_set_t& AuxVectorData::getAuxIDs() const
{
  const SG::IConstAuxStore* store = getConstStore();
  if (store)
    return store->getAuxIDs();
  return s_emptySet;
}
 

SG::auxid_set_t AuxVectorData::getCopyIDs (bool warnUnlocked /*= false*/) const
{
  const SG::IConstAuxStore* store = getConstStore();
  if (store)
    return store->getCopyIDs (warnUnlocked);
  return SG::auxid_set_t();
}
 

const SG::auxid_set_t& AuxVectorData::getDecorIDs() const
{
  if (getConstStore())
    return getConstStore()->getDecorIDs();
  return s_emptySet;
}
 

const SG::auxid_set_t& AuxVectorData::getWritableAuxIDs() const
{
  if (m_store)
    return m_store->getWritableAuxIDs();
  return s_emptySet;
}
 

bool AuxVectorData::isAvailableOol (auxid_t id) const
{
  guard_t guard (m_mutex);
 
  const SG::IConstAuxStore* store = getConstStore();
  if (!store) return false;
 
  // Don't rely on getAuxIDs() --- the store can lie.
  // Explicitly try to fetch the data.
  const void* ptr = store->getData (id);
  if (ptr) {
    // We could avoid the const_cast here by having distinct const and
    // non-const Cache types, holding const void* and void*, respectively.
    // However, since this is a purely internal class that users don't
    // deal with directly, that's not worth the bother (and the extra code).
    void* vp ATLAS_THREAD_SAFE = const_cast<void*> (ptr);
    m_constCache.store (id, vp);
    return true;
  }
  return false;
}
 

bool AuxVectorData::isAvailableWritableOol (auxid_t id)
{
  const SG::IAuxStore* store = getStore();
  if (!store) return false;
  return store->getWritableAuxIDs().test(id);
}
 

bool AuxVectorData::isAvailableWritableAsDecorationOol (auxid_t id) const
{
  if (!isAvailableOol (id)) return false;
 
  // Not nice, but not sure we can do otherwise without changing interfaces.
  // I think the case of a caught exception should be rare.
  try {
    this->getDecorationArray (id);
  }
  catch (const SG::ExcStoreLocked&) {
    return false;
  }
  return true;
}
 

void* AuxVectorData::getDataOol (SG::auxid_t auxid, bool allowMissing)
{
  guard_t guard (m_mutex);
 
  // Fetch the pointer from the store, or raise an exception if we don't
  // have a non-const store.
  void* ptr = 0;
  if (m_store) {
    if (SG::AuxTypeRegistry::instance().isLinked (auxid)) {
      ptr = m_store->getData (auxid, 0, 0);
    }
    else {
      ptr = m_store->getData (auxid, this->size_v(), this->capacity_v());
    }
  }
  else if (getConstStore())
    throw SG::ExcConstAuxData ("fetch item", auxid);
  else
    throw SG::ExcNoAuxStore (auxid);
 
  // Check that we got a good pointer back, otherwise throw.
  if (ptr) {
    m_cache.store (auxid, ptr);
 
    // Set the same entry in the other caches as well.
    m_constCache.store (auxid, ptr);
    m_decorCache.store (auxid, ptr);
  }
  else if (!allowMissing)
    throw SG::ExcBadAuxVar (auxid);
 
  return ptr;
}
 

const void* AuxVectorData::getDataOol (SG::auxid_t auxid,
                                       bool allowMissing) const
{
  guard_t guard (m_mutex);
 
  // Fetch the pointer from the store, or raise an exception if we don't
  // have a const store.
  const void* ptr = 0;
  const SG::IConstAuxStore* store = getConstStore();
  if (store)
    ptr = store->getData (auxid);
  else
    throw SG::ExcNoAuxStore (auxid);
 
  // Check that we got a good pointer back, otherwise throw.
  if (ptr) {
    // We could avoid the const_cast here by having distinct const and
    // non-const Cache types, holding const void* and void*, respectively.
    // However, since this is a purely internal class that users don't
    // deal with directly, that's not worth the bother (and the extra code).
    void* vp ATLAS_THREAD_SAFE = const_cast<void*> (ptr);
    m_constCache.store (auxid, vp);
  }
  else if (!allowMissing)
    throw SG::ExcBadAuxVar (auxid);
 
  return ptr;
}
 

void* AuxVectorData::getDecorationOol (SG::auxid_t auxid) const
{
  guard_t guard (m_mutex);
 
  // Fetch the pointer from the store, or raise an exception if we don't
  // have a non-const store.
  void* ptr = 0;
  if (m_store) {
    // Avoid warning about calling non-const function.  OK here.
    IAuxStore* store ATLAS_THREAD_SAFE = m_store;
    if (SG::AuxTypeRegistry::instance().isLinked (auxid)) {
      ptr = store->getDecoration (auxid, 0, 0);
    }
    else {
      ptr = store->getDecoration (auxid, this->size_v(), this->capacity_v());
    }
  }
  else if (getConstStore()) {
    // The whole point of decorations is to allow adding information to
    // something that's otherwise const.  So we have the const_cast here.
    // The store object is responsible for determining whether the
    // modification is really allowed or not.
    IConstAuxStore* store ATLAS_THREAD_SAFE =
       const_cast<IConstAuxStore*> (getConstStore());
    if (SG::AuxTypeRegistry::instance().isLinked (auxid)) {
      ptr = store->getDecoration (auxid, 0, 0);
    }
    else {
      ptr = store->getDecoration (auxid, this->size_v(), this->capacity_v());
    }
  }
  else
    throw SG::ExcNoAuxStore (auxid);
 
  // Check that we got a good pointer back, otherwise throw.
  if (!ptr)
    throw SG::ExcBadAuxVar (auxid);
 
  m_decorCache.store (auxid, ptr);
 
  // Set the same entry in the const cache as well.
  m_constCache.store (auxid, ptr);
 
  return ptr;
}
 

const AuxDataSpanBase*
AuxVectorData::getDataSpanOol (SG::auxid_t auxid, bool allowMissing) const
{
  guard_t guard (m_mutex);
 
  // Fetch the pointer from the store, or raise an exception if we don't
  // have a const store.
  const IAuxTypeVector* v = 0;
  const SG::IConstAuxStore* store = getConstStore();
  if (store)
    v = store->getVector (auxid);
  else
    throw SG::ExcNoAuxStore (auxid);
 
  // Check that we got a good pointer back, otherwise throw.
  const AuxDataSpanBase* ptr = nullptr;
  if (v) {
    ptr = &v->getDataSpan();
    // We could avoid the const_cast here by having distinct const and
    // non-const Cache types, holding const void* and void*, respectively.
    // However, since this is a purely internal class that users don't
    // deal with directly, that's not worth the bother (and the extra code).
    AuxDataSpanBase* vp ATLAS_THREAD_SAFE = const_cast<AuxDataSpanBase*> (ptr);
    m_spanCache.store (auxid, vp);
  }
  else if (!allowMissing)
    throw SG::ExcBadAuxVar (auxid);
 
  return ptr;
}
 

AuxVectorData::Cache::Cache()
  : m_cache(),
    m_cache_len(0)
{
}
 

AuxVectorData::Cache::Cache (Cache&& rhs)
  : m_cache_len (rhs.m_cache_len),
    m_allcache (std::move (rhs.m_allcache))
{
  m_cache[0] = rhs.m_cache[0];
  m_cache[1] = rhs.m_cache[1];
  rhs.m_cache[0] = 0;
  rhs.m_cache[1] = 0;
  rhs.m_cache_len = 0;
}
 

AuxVectorData::Cache& AuxVectorData::Cache::operator= (Cache&& rhs)
{
  if (this != &rhs) {
    clear();
    m_cache_len = rhs.m_cache_len;
    m_allcache = std::move (rhs.m_allcache);
    
    m_cache[0] = rhs.m_cache[0];
    m_cache[1] = rhs.m_cache[1];
    rhs.m_cache[0] = 0;
    rhs.m_cache[1] = 0;
    rhs.m_cache_len = 0;
  }
  return *this;
}
 

AuxVectorData::Cache::~Cache()
{
  for (size_t i=0; i < m_allcache.size(); i++) delete [] m_allcache[i];
}
 

void AuxVectorData::Cache::swap (Cache& other)
{
  m_allcache.swap (other.m_allcache);
  std::swap (m_cache, other.m_cache);
  std::swap (m_cache_len, other.m_cache_len);
}
 

void AuxVectorData::Cache::clear()
{
  if (m_cache_len > 0) {
    if (m_allcache.size() > 1) {
      for (size_t i=0; i < m_allcache.size()-1; i++)
        delete [] m_allcache[i];
      m_allcache[0] = m_allcache.back();
      m_allcache.resize(1);
    }
    std::fill (m_cache[0], m_cache[0] + m_cache_len, static_cast<void*>(0));
  }
}
 

void AuxVectorData::Cache::clear (SG::auxid_t auxid)
{
  if (auxid < m_cache_len) {
    m_cache[0][auxid] = nullptr;
  }
}
 

void AuxVectorData::Cache::store (SG::auxid_t auxid, void* ptr)
{
  // We must be holding the container lock m_mutex to call this.
 
  if (auxid >= m_cache_len) {
    // We need to expand the cache vector.   Allocate a new one.
    size_t newlen =
      std::max (static_cast<SG::auxid_t>(AuxVectorData::s_minCacheLen),
                (auxid+1)*3/2);
    void** newcache = new void*[newlen];
    m_allcache.push_back (newcache);
    void** oldcache = m_cache[0];
 
    // Copy old vector to the new one and clear the remainder.
    std::copy (oldcache, oldcache + m_cache_len, newcache);
    std::fill (newcache + m_cache_len, newcache + newlen,
               static_cast<void*>(0));
 
    // The above writes must be visible before we update the cache pointers.
    AthContainers_detail::fence_seq_cst();
 
    // Store so that other threads can see it.
    // The stores to m_cache must happen before the store to m_cache_len;
    // we use a fence to ensure this.
    m_cache[0] = newcache;
    m_cache[1] = newcache;
    AthContainers_detail::fence_seq_cst();
    m_cache_len = newlen;
  }
 
  // We have room in the cache vector now.  Store the pointer.
  m_cache[0][auxid] = ptr;
}
 

void AuxVectorData::lock()
{
  if (m_store) {
    m_store->lock();
    clearCache();
  }
 
  // No error if no store or no writable store.
}
 

bool AuxVectorData::clearDecorations() const
{
  bool ret = false;
  if (m_store) {
    // Avoid warning about calling non-const function.  OK here.
    IAuxStore* store ATLAS_THREAD_SAFE = m_store;
    ret = store->clearDecorations();
    m_cache.clear();
    m_constCache.clear();
    m_decorCache.clear();
  }
  else if (getConstStore()) {
    // The whole point of decorations is to allow adding information to
    // something that's otherwise const.  So we have the const_cast here.
    // The store object is responsible for determining whether the
    // modification is really allowed or not.
    IConstAuxStore* store ATLAS_THREAD_SAFE =
       const_cast<IConstAuxStore*> (getConstStore());
    ret = store->clearDecorations();
  }
  else
    throw SG::ExcNoAuxStore ("lock");
  return ret;
}
 

void AuxVectorData::lockDecoration (SG::auxid_t auxid)
{
  const IConstAuxStore* store = this->getConstStore();
  if (store) {
    // Casting away const ok if no other thread is accessing this decoration.
    IConstAuxStore* store_nc ATLAS_THREAD_SAFE = const_cast<IConstAuxStore*> (store);
    store_nc->lockDecoration (auxid);
    this->clearDecorCache (auxid);
  }
}
 

const SG::IConstAuxStore* AuxVectorData::getConstStoreOol() const
{
  return getConstStore();
}
 
 
 
} // namespace SG