AuxStoreInternal.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
 
#include <iostream>
#include <sstream>
#include <atomic>
#include <algorithm>
 
#include "AthContainers/AuxStoreInternal.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/PackedParameters.h"
#include "AthContainers/exceptions.h"
#include "AthContainers/tools/error.h"
 
 
namespace SG {
 

AuxStoreInternal::AuxStoreInternal (bool standalone /*= false*/)
  : m_standalone (standalone),
    m_locked (false)
{
}
 

AuxStoreInternal::~AuxStoreInternal()
{
}
 

AuxStoreInternal::AuxStoreInternal (const AuxStoreInternal& other)
{
  guard_t guard (other.m_mutex);
  m_standalone = other.m_standalone;
  m_decorations = other.m_decorations;
  m_auxids = other.m_auxids;
  m_locked = other.m_locked;
  size_t size = other.m_vecs.size();
  m_vecs.resize (size);
  for (size_t i = 0; i < size; i++) {
    if (other.m_vecs[i])
      m_vecs[i] = other.m_vecs[i]->clone();
  }
}
 

bool AuxStoreInternal::standalone() const
{
  return m_standalone;
}
 

const void* AuxStoreInternal::getData (auxid_t auxid) const
{
  const IAuxTypeVector* v = getVector (auxid);
  if (v) {
    return v->toPtr();
  }
  return nullptr;
}
 

const IAuxTypeVector* AuxStoreInternal::getVector (auxid_t auxid) const
{
  guard_t guard (m_mutex);
  if (auxid >= m_vecs.size() || !m_vecs[auxid]) {
    // With the new behavior of SG::Accessor::isAvailable,
    // we shouldn't print an error message here. Asking the store whether
    // it has an element using this function is not necessarily an
    // error condition by now. In any case, the DataVector code will
    // complain itself in case of an error.
    return 0;
  }
  return m_vecs[auxid].get();
}
 

void* AuxStoreInternal::getData (auxid_t auxid, size_t size, size_t capacity)
{
  return getDataInternal (auxid, size, capacity, false);
}
 

IAuxTypeVector*
AuxStoreInternal::addVector (std::unique_ptr<IAuxTypeVector> vec,
                             bool isDecoration)
{
  guard_t guard (m_mutex);
  auxid_t auxid = vec->auxid();
  if (m_locked)
    throw ExcStoreLocked (auxid);
 
  // Resize the vector if needed.
  if (m_vecs.size() <= auxid) {
    m_vecs.resize (auxid+1);
  }
 
  // Give up if the variable is already present in the store.
  if (m_vecs[auxid]) std::abort();
 
  // Make sure the length is consistent with the rest of the store.
  if (!vec->isLinked()) {
    size_t sz = this->size_noLock();
    if (vec->size() < sz)
      vec->resize (sz);
  }
 
  // Add it to the store.
  m_vecs[auxid] = std::move (vec);
 
  // Need to be sure that the addition to the decoration bitset is visible
  // to other threads before the addition to the variable bitset.
  if (isDecoration) {
    m_decorations.insert (auxid);
    std::atomic_thread_fence (std::memory_order_seq_cst);
  }
  addAuxID (auxid);
 
  return m_vecs[auxid].get();
}
 

void*
AuxStoreInternal::getDecoration (auxid_t auxid, size_t size, size_t capacity)
{
  guard_t guard (m_mutex);
  if (m_vecs.size() <= auxid) {
    m_vecs.resize (auxid+1);
  }
  if (m_vecs[auxid] == 0) {
    m_vecs[auxid] = AuxTypeRegistry::instance().makeVector (auxid, size, capacity);
    std::unique_ptr<IAuxTypeVector> linked = m_vecs[auxid]->linkedVector();
    auxid_t linked_id = null_auxid;
    if (linked) {
      linked_id = linked->auxid();
      m_vecs[linked_id] = std::move (linked);
    }
    if (m_locked) {
      // Need to be sure that the addition to the decoration bitset is visible
      // to other threads before the addition to the variable bitset.
      m_decorations.insert (auxid);
      if (linked_id != null_auxid) {
        m_decorations.insert (linked_id);
      }
      std::atomic_thread_fence (std::memory_order_seq_cst);
    }
    addAuxID (auxid);
    if (linked_id != null_auxid) {
      addAuxID (linked_id);
    }
  }
  if (m_locked && !m_decorations.test (auxid)) {
    throw ExcStoreLocked (auxid);
  }
  return m_vecs[auxid]->toPtr();
}
 

bool AuxStoreInternal::resize (size_t sz)
{
  guard_t guard (m_mutex);
  if (m_locked)
    throw ExcStoreLocked ("resize");
  bool nomoves = true;
  for (SG::auxid_t id : m_auxids) {
    SG::IAuxTypeVector* v = nullptr;
    if (id < m_vecs.size())
      v = m_vecs[id].get();
    if (v && !v->isLinked()) {
      if (!v->resize (sz))
        nomoves = false;
    }
  }
  return nomoves;
}
 

void AuxStoreInternal::reserve (size_t sz)
{
  guard_t guard (m_mutex);
  if (m_locked)
    throw ExcStoreLocked ("reserve");
  for (std::unique_ptr<IAuxTypeVector>& v : m_vecs) {
    if (v && !v->isLinked())
      v->reserve (sz);
  }
}
 

void AuxStoreInternal::shift (size_t pos, ptrdiff_t offs)
{
  guard_t guard (m_mutex);
  if (m_locked)
    throw ExcStoreLocked ("shift");
  for (std::unique_ptr<IAuxTypeVector>& v : m_vecs) {
    if (v && !v->isLinked())
      v->shift (pos, offs);
  }
}
 

bool AuxStoreInternal::insertMove (size_t pos,
                                   IAuxStore& other,
                                   const SG::auxid_set_t& ignore)
{
  guard_t guard (m_mutex);
  const AuxTypeRegistry& r = AuxTypeRegistry::instance();
 
  if (m_locked)
    throw ExcStoreLocked ("insertMove");
  bool nomove = true;
  size_t other_size = other.size();
  if (other_size == 0)
    return true;
  for (SG::auxid_t id : m_auxids) {
    SG::IAuxTypeVector* v_dst = nullptr;
    if (id < m_vecs.size())
      v_dst = m_vecs[id].get();
    // Skip linked vars --- they should be taken care of by the parent var.
    if (v_dst && !v_dst->isLinked()) {
      if (other.getData (id)) {
        void* src_ptr = other.getData (id, other_size, other_size);
        if (src_ptr) {
          if (!v_dst->insertMove (pos, src_ptr, 0, other_size,
                                  other))
            nomove = false;
        }
      }
      else {
        const void* orig = v_dst->toPtr();
        v_dst->shift (pos, other_size);
        if (orig != v_dst->toPtr())
          nomove = false;
      }
    }
  }
 
  // Add any new variables not present in the original container.
  for (SG::auxid_t id : other.getAuxIDs()) {
    if (!m_auxids.test(id) && !ignore.test(id))
    {
      if (r.isLinked (id)) continue;
      if (other.getData (id)) {
        void* src_ptr = other.getData (id, other_size, other_size);
        if (src_ptr) {
          size_t sz = size_noLock();
          if (sz < other_size) sz = other_size + pos;
          IAuxTypeVector* v = getVectorInternal_noLock (id, sz, sz, false);
          v->resize (sz - other_size);
          (void)v->insertMove (pos, src_ptr, 0, other_size,
                               other);
          nomove = false;
        }
      }
    }
  }
  
  return nomove;
}
 

const SG::auxid_set_t&
AuxStoreInternal::getAuxIDs() const
{
  return m_auxids;
}
 

const SG::auxid_set_t&
AuxStoreInternal::getDecorIDs() const
{
  return m_decorations;
}
 

SG::auxid_set_t AuxStoreInternal::getCopyIDs (bool warnUnlocked) const
{
  return SG::getCopyIDs (m_auxids, m_decorations, warnUnlocked, {});
}
 

bool AuxStoreInternal::isDecoration (auxid_t auxid) const
{
  return m_decorations.test (auxid);
}
 

const SG::auxid_set_t&
AuxStoreInternal::getWritableAuxIDs() const
{
  return getAuxIDs();
}
 

const void* AuxStoreInternal::getIODataInternal (auxid_t auxid, bool quiet) const
{
  guard_t guard (m_mutex);
  if (auxid >= m_vecs.size() || !m_vecs[auxid]) {
    if (!quiet) {
      std::ostringstream ss;
      ss  << "Requested variable "
          << SG::AuxTypeRegistry::instance().getName (auxid)
          << " (" << auxid << ") doesn't exist";
      ATHCONTAINERS_ERROR("AuxStoreInternal::getIODataInternal", ss.str());
    }
    return 0;
  }
 
  if (m_standalone) {
    if (!SG::AuxTypeRegistry::instance().isLinked (auxid))
      return m_vecs[auxid]->toPtr();
  }
  return m_vecs[auxid]->toVector();
}
 

void* AuxStoreInternal::getIODataInternal (auxid_t auxid, bool quiet)
{
  guard_t guard (m_mutex);
  if (auxid >= m_vecs.size() || !m_vecs[auxid]) {
    if (!quiet) {
      std::ostringstream ss;
      ss  << "Requested variable "
          << SG::AuxTypeRegistry::instance().getName (auxid)
          << " (" << auxid << ") doesn't exist";
      ATHCONTAINERS_ERROR("AuxStoreInternal::getIODataInternal", ss.str());
    }
    return 0;
  }
 
  if (m_standalone) {
    if (!SG::AuxTypeRegistry::instance().isLinked (auxid))
      return m_vecs[auxid]->toPtr();
  }
  return m_vecs[auxid]->toVector();
}
 

const void* AuxStoreInternal::getIOData (auxid_t auxid) const
{
  return getIODataInternal (auxid, false);
}
 

const std::type_info* AuxStoreInternal::getIOType (auxid_t auxid) const
{
  if (m_standalone) {
    const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
    if (!r.isLinked (auxid))
      return r.getType (auxid);
  }
  guard_t guard (m_mutex);
  if (auxid < m_vecs.size() && m_vecs[auxid]) {
    const std::type_info* ret = m_vecs[auxid]->objType();
    if (ret) return ret;
  }
  return SG::AuxTypeRegistry::instance().getVecType (auxid);
}
 

const SG::auxid_set_t&
AuxStoreInternal::getDynamicAuxIDs() const
{
  return getAuxIDs();
}
 

void AuxStoreInternal::lock()
{
  guard_t guard (m_mutex);
  m_locked = true;
}
 

bool AuxStoreInternal::clearDecorations()
{
  guard_t guard (m_mutex);
  bool anycleared = false;
  for (auxid_t id : m_decorations) {
    m_vecs[id].reset();
    m_auxids.erase (id);
    anycleared = true;
  }
  if (anycleared) {
    m_decorations.clear();
  }
  return anycleared;
}
 

size_t AuxStoreInternal::size() const
{
  guard_t guard (m_mutex);
  return size_noLock();
}
 

size_t AuxStoreInternal::size_noLock() const
{
  for (SG::auxid_t id : m_auxids) {
    if (id < m_vecs.size() && m_vecs[id] && !m_vecs[id]->isLinked() &&
        m_vecs[id]->size() > 0)
    {
      return m_vecs[id]->size();
    }
  }
  return 0;
}
 

bool AuxStoreInternal::setOption (auxid_t id, const AuxDataOption& option)
{
  // Does this variable exist in this store?
  bool exists = false;
  {
    guard_t guard (m_mutex);
    if (id < m_vecs.size() && m_vecs[id] != 0)
      exists = true;
  }
 
  // If not, and we have a packing parameter request, then create the variable.
  if (!exists) {
    if (!PackedParameters::isValidOption (option)) return false;
    size_t sz = size();
    getDataInternal (id, sz, sz, true);
  }
 
  // Try the option setting.
  guard_t guard (m_mutex);
  if (m_vecs[id]->setOption (option)) return true;
 
  // It didn't work.  If this is a packing request, then try to convert
  // the variable to packed form and retry.
  if (!PackedParameters::isValidOption (option)) return false;
  std::unique_ptr<IAuxTypeVector> packed = m_vecs[id]->toPacked();
  if (packed) {
    // Converted to packed form.  Replace the object and retry.
    m_vecs[id] = std::move (packed);
    return m_vecs[id]->setOption (option);
  }
 
  // Didn't work.
  return false;
}
 

void AuxStoreInternal::addAuxID (auxid_t auxid)
{
  m_auxids.insert (auxid);
}
 

IAuxTypeVector*
AuxStoreInternal::getVectorInternal_noLock (auxid_t auxid,
                                            size_t size,
                                            size_t capacity,
                                            bool no_lock_check)
{
  if (m_vecs.size() <= auxid) {
    m_vecs.resize (auxid+1);
  }
  if (m_vecs[auxid] == 0) {
    if (m_locked && !no_lock_check)
      throw ExcStoreLocked (auxid);
    const AuxTypeRegistry& r = AuxTypeRegistry::instance();
    m_vecs[auxid] = r.makeVector (auxid, size, capacity);
    addAuxID (auxid);
    std::unique_ptr<IAuxTypeVector> linked = m_vecs[auxid]->linkedVector();
    if (linked) {
      auxid_t linked_id = linked->auxid();
      m_vecs[linked_id] = std::move (linked);
      addAuxID (linked_id);
    }
  }
  else {
    // Make sure the vector has at least the requested size.
    // One way in which it could be short: setOption was called and created
    // a variable in a store that had no other variables.
    if (m_vecs[auxid]->size() < size) {
      m_vecs[auxid]->resize (size);
      m_vecs[auxid]->reserve (capacity);
    }
  }
  return m_vecs[auxid].get();
}
 

void* AuxStoreInternal::getDataInternal (auxid_t auxid,
                                         size_t size,
                                         size_t capacity,
                                         bool no_lock_check)
{
  guard_t guard (m_mutex);
  return getVectorInternal_noLock (auxid, size, capacity, no_lock_check)->toPtr();
}
 

void AuxStoreInternal::lockDecoration (SG::auxid_t auxid)
{
  guard_t guard (m_mutex);
  m_decorations.reset (auxid);
}
 

IAuxTypeVector* AuxStoreInternal::linkedVector (SG::auxid_t auxid)
{
  const AuxTypeRegistry& r = AuxTypeRegistry::instance();
  auxid_t linked_id = r.linkedVariable (auxid);
  guard_t guard (m_mutex);
  if (linked_id < m_vecs.size())
    return m_vecs[linked_id].get();
  return nullptr;
}
 

const IAuxTypeVector* AuxStoreInternal::linkedVector (SG::auxid_t auxid) const
{
  const AuxTypeRegistry& r = AuxTypeRegistry::instance();
  auxid_t linked_id = r.linkedVariable (auxid);
  guard_t guard (m_mutex);
  if (linked_id < m_vecs.size())
    return m_vecs[linked_id].get();
  return nullptr;
}
 

SG::auxid_set_t getCopyIDs (const SG::auxid_set_t& auxids,
                            const SG::auxid_set_t& decors,
                            [[maybe_unused]] bool warnUnlocked,
                            [[maybe_unused]] std::span<const std::string> noWarn)
{
  SG::auxid_set_t out = auxids;
#ifndef XAOD_STANDALONE
  if (warnUnlocked) {
    SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
    for (SG::auxid_t decor : decors) {
      if (out.test (decor)) {
        out.reset (decor);
        if (std::ranges::find (noWarn, r.getName (decor)) == noWarn.end()) {
          std::ostringstream ss;
          ss << "skipped unlocked decoration during copy " << r.getName(decor)
             << " (" << decor << ")";
          ATHCONTAINERS_WARNING("getCopyAuxIDs", ss.str());
        }
      }
    }
  }
  else
#endif
    out -= decors;
  return out;
}
 
 
} // namespace SG