AuxContainerBase.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
// System include(s):
#include <iostream>
#include <memory_resource>
 
// EDM include(s):
#include "AthContainers/AuxStoreInternal.h"
#include "AthContainers/AuxTypeRegistry.h"
#include "AthContainers/exceptions.h"
 
// Local include(s):
#include "xAODCore/AuxContainerBase.h"
#include "xAODCore/tools/IOStats.h"
#include "xAODCore/tools/ReadStats.h"
 
#ifndef XAOD_STANDALONE
#   include "GaudiKernel/ThreadLocalContext.h"
#   include "AthenaKernel/ExtendedEventContext.h"
#endif // not XAOD_STANDALONE
 
#include "CxxUtils/as_const_ptr.h"
#include "CxxUtils/checker_macros.h"
 
using namespace std;
 
namespace xAOD {
 
   AuxContainerBase::AuxContainerBase( bool allowDynamicVars )
      : AuxContainerBase( nullptr, allowDynamicVars ) {
   }
 
   AuxContainerBase::AuxContainerBase( std::pmr::memory_resource* memResource,
                                       bool allowDynamicVars )
      : SG::IAuxStore(),
        m_auxids(), m_vecs(), m_store( nullptr ), m_storeIO( nullptr ),
        m_ownsStore( true ),
        m_locked( false ),
        m_name( "UNKNOWN" ),
        m_memResource( memResource ){
 
      if( allowDynamicVars ) {
         m_store = new SG::AuxStoreInternal();
         m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
      }
   }
 
   AuxContainerBase::AuxContainerBase( const AuxContainerBase& parent )
      : SG::IAuxStore(),
        m_auxids(), m_vecs(), m_store( nullptr ), m_storeIO( nullptr ),
        m_ownsStore( true ),
        m_locked( false ),
        m_memResource( parent.m_memResource )
   {
      // Keep the source unmutable during copy
      guard_t guard( parent.m_mutex );
      m_name = parent.m_name;
 
      // Unfortunately the dynamic variables can not be copied this easily...
      if( parent.m_store ) {
         m_ownsStore = false;
         // cppcheck-suppress copyCtorPointerCopying
         m_store = parent.m_store;
         m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
         m_auxids = m_store->getAuxIDs();
      }
   }
 
   AuxContainerBase::AuxContainerBase( SG::IAuxStore* store,
                                       std::pmr::memory_resource* memResource )
      : SG::IAuxStore(),
        m_auxids(), m_vecs(),
        m_store( store ),
        m_storeIO( nullptr ), m_ownsStore( false ),
        m_locked( false),
        m_name( "UNKNOWN" ),
        m_memResource( memResource ){
 
      m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
      if( m_store ) {
         m_auxids = m_store->getAuxIDs();
      }
   }
 
   AuxContainerBase::~AuxContainerBase() {
 
      std::vector< SG::IAuxTypeVector* >::iterator itr = m_vecs.begin();
      std::vector< SG::IAuxTypeVector* >::iterator end = m_vecs.end();
      for( ; itr != end; ++itr ) {
         if( ! *itr ) continue;
         delete *itr;
      }
 
      if( m_store && m_ownsStore ) delete m_store;
   }
 
   AuxContainerBase&
   AuxContainerBase::operator=( const AuxContainerBase& rhs ) {
 
      // Protect against self-assignment:
      if( this == &rhs ) return *this;
 
      // Keep the objects locked during copy
      std::scoped_lock  lck{m_mutex, rhs.m_mutex};
 
      // Clean up after the old dynamic store:
      if( m_store && m_ownsStore ) {
         m_auxids -= m_store->getAuxIDs();
         delete m_store;
      }
      m_store = nullptr;
      m_storeIO = nullptr;
      m_ownsStore = true;
 
      // Take posession of the new dynamic store:
      if( rhs.m_store ) {
         m_store = rhs.m_store;
         m_ownsStore = false;
         m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
         m_auxids.insert (m_store->getAuxIDs());
      }
 
      m_name = rhs.m_name;
 
      return *this;
   }
 
   //
   //         Implementation of the SG::IAuxStoreHolder functions
   //
 
   SG::IAuxStore* AuxContainerBase::getStore()
   {
      return m_store;
   }
 
   std::pmr::memory_resource* AuxContainerBase::memResource()
   {
      const std::pmr::memory_resource* cptr = m_memResource.get();
      std::pmr::memory_resource* ptr ATLAS_THREAD_SAFE  = const_cast<std::pmr::memory_resource*>( cptr );
      if( !ptr ) {
#ifndef XAOD_STANDALONE
         const EventContext& ctx = Gaudi::Hive::currentContext();
         if( Atlas::hasExtendedEventContext( ctx ) ) {
            ptr = Atlas::getExtendedEventContext( ctx ).memResource();
         }
         if( !ptr )
#endif
         {
            ptr = std::pmr::get_default_resource();
         }
         if( ptr ) {
           m_memResource.set( ptr );
         }
      }
      return ptr;
   }
 
   const SG::IAuxStore* AuxContainerBase::getStore() const
   {
      return m_store;
   }
 
   void AuxContainerBase::setStore( SG::IAuxStore* store ) {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Check that no funny business is going on:
      if( m_store == store ) return;
 
      // Clean up the current store object:
      if( m_store && m_ownsStore ) {
         m_auxids -= m_store->getAuxIDs();
         delete m_store;
      }
      m_store = nullptr;
      m_storeIO = nullptr;
 
      // Take posession of the new object:
      m_store = store;
      m_storeIO = dynamic_cast< SG::IAuxStoreIO* >( m_store );
      m_ownsStore = true;
      if( m_store ) {
         m_auxids.insert (m_store->getAuxIDs());
      }
 
      return;
   }
 
   //
 
   //
   //          Implementation of the SG::IConstAuxStore functions
   //
 
   const void* AuxContainerBase::getData( auxid_t auxid ) const {
 
      const SG::IAuxTypeVector* v = getVector( auxid );
      if( v ) {
         return v->toPtr();
      }
      return nullptr;
   }
 
   const SG::IAuxTypeVector* AuxContainerBase::getVector( auxid_t auxid ) const {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         if( m_store ) {
            const SG::IAuxTypeVector* result = m_store->getVector( auxid );
            if( result ) {
              auxid_set_t& auxids_nc ATLAS_THREAD_SAFE =
                const_cast<auxid_set_t&> (m_auxids);
              auxids_nc.insert( auxid );
              const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
              auxid_t linked_id = r.linkedVariable( auxid );
              if (linked_id != SG::null_auxid) {
                 auxids_nc.insert( linked_id );
              }
            }
            return result;
         } else {
            std::cout << "ERROR xAOD::AuxContainerBase::getData "
                      << "Unknown variable ("
                      << SG::AuxTypeRegistry::instance().getName( auxid )
                      << ") requested" << std::endl;
            return nullptr;
         }
      }
 
      // Update the statistics for this variable. The dynamic store registers
      // its own variable accesses.
      IOStats::instance().stats().readBranch( m_name, auxid );
 
      return m_vecs[ auxid ];
   }
 
   const AuxContainerBase::auxid_set_t&
   AuxContainerBase::getAuxIDs() const {
 
      // Return the full list of IDs:
      return getWritableAuxIDs();
   }
 
   const AuxContainerBase::auxid_set_t&
   AuxContainerBase::getDecorIDs() const {
 
      if( m_store ) {
         return m_store->getDecorIDs();
      }
      static const auxid_set_t empty;
      return empty;
   }
 
   bool AuxContainerBase::isDecoration (auxid_t auxid) const
   {
     guard_t guard( m_mutex );
     if (m_store) {
       return m_store->isDecoration (auxid);
     }
     return false;
   }
 
   void* AuxContainerBase::getDecoration( auxid_t auxid, size_t size,
                                          size_t capacity ) {
     {
       // Guard against multi-threaded execution:
       guard_t guard( m_mutex );
 
       // Check if we have it as a static variable:
       if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         // If not, but we have a dynamic store, push it in there:
         if( m_store ) {
           void* result = m_store->getDecoration( auxid, size, capacity );
           if( result ) {
              m_auxids.insert( auxid );
              const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
              auxid_t linked_id = r.linkedVariable( auxid );
              if (linked_id != SG::null_auxid) {
                 m_auxids.insert( linked_id );
              }
           }
           return result;
         }
         // If we don't have a dynamic store, complain:
         else {
           std::cout << "ERROR xAOD::AuxContainerBase::getDecoration "
                     << "Can't provide variable "
                     << SG::AuxTypeRegistry::instance().getName( auxid )
                     << std::endl;
           return nullptr;
         }
       }
 
       // If the container is locked, static variables can't be accessed this
       // way:
       if( m_locked ) {
         throw SG::ExcStoreLocked( auxid );
       }
     }
 
     // If the container is not locked, then fall back on the normal accessor
     // function:
     return getData( auxid, size, capacity );
   }
 
   void AuxContainerBase::lock() {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Lock the object and its dynamic store:
      m_locked = true;
      if( m_store ) {
         m_store->lock();
      }
 
      return;
   }
 
   bool AuxContainerBase::clearDecorations() {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // Clear the decorations from the dynamic store:
      bool anycleared = false;
      if( m_store ) {
         anycleared = m_store->clearDecorations();
      }
      // Early exit if there were no decorations.
      if (!anycleared) return false;
 
      // Construct the list of managed auxiliary variables from scratch after
      // the cleanup:
      auxid_set_t ids;
      for( auxid_t auxid = 0; auxid < m_vecs.size(); ++auxid ) {
         if( m_vecs[ auxid ] ) {
            ids.insert( auxid );
         }
      }
      if( m_store ) {
         ids.insert (m_store->getAuxIDs());
      }
      m_auxids = ids;
 
      return true;
   }
   
   void AuxContainerBase::lockDecoration (SG::auxid_t auxid)
   { 
     guard_t guard (m_mutex);
     if (m_store) {
       m_store->lockDecoration (auxid);
     }
   }
 
 
   const SG::IAuxTypeVector* AuxContainerBase::linkedVector (SG::auxid_t auxid) const
   {
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      auxid_t linked_id = r.linkedVariable( auxid );
      if (linked_id != SG::null_auxid) {
         guard_t guard( m_mutex );
         if (linked_id < m_vecs.size() && m_vecs[ linked_id ]) {
            return m_vecs[ linked_id ];
         }
         if (m_store) {
            return CxxUtils::as_const_ptr(m_store)->linkedVector( auxid );
         }
      }
      return nullptr;
   }
 
 
   SG::IAuxTypeVector* AuxContainerBase::linkedVector (SG::auxid_t auxid)
   {
      const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
      auxid_t linked_id = r.linkedVariable( auxid );
      if (linked_id != SG::null_auxid) {
         guard_t guard( m_mutex );
         if (linked_id < m_vecs.size() && m_vecs[ linked_id ]) {
            return m_vecs[ linked_id ];
         }
         if (m_store) {
            return m_store->linkedVector( auxid );
         }
      }
      return nullptr;
   }
 
 
   size_t AuxContainerBase::size() const {
 
      // Guard against multi-threaded execution:
      guard_t guard (m_mutex);
 
      // Try to find a variable:
      for (SG::auxid_t i : m_auxids) {
         if( ( i < m_vecs.size() ) && m_vecs[ i ] && !m_vecs[ i ]->isLinked()) {
            size_t sz = m_vecs[ i ]->size();
            if( sz > 0 ) {
               return sz;
            }
         }
      }
 
      // If we didn't find any, let's ask the dynamic store:
      if( m_store ) {
         return m_store->size();
      }
 
      // If we don't have any variables, then the size must be null:
      return 0;
   }
 
   //
 
   //
   //             Implementation of the SG::IAuxStore functions
   //
 
   void* AuxContainerBase::getData( auxid_t auxid, size_t size,
                                    size_t capacity ) {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
 
         if( m_store ) {
            void* result = m_store->getData( auxid, size, capacity );
            if( result ) {
               m_auxids.insert( auxid );
               const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
               auxid_t linked_id = r.linkedVariable( auxid );
               if (linked_id != SG::null_auxid) {
                  m_auxids.insert( linked_id );
               }
            }
            return result;
         } else {
            std::cout << "ERROR xAOD::AuxContainerBase::getData "
                      << "Unknown variable ("
                      << SG::AuxTypeRegistry::instance().getName( auxid )
                      << ") requested" << std::endl;
            return nullptr;
         }
      }
      m_vecs[ auxid ]->reserve( capacity );
      if (m_vecs[ auxid ]->size() < size) {
         m_vecs[ auxid ]->resize( size );
      }
 
      return m_vecs[ auxid ]->toPtr();
   }
 
   const AuxContainerBase::auxid_set_t&
   AuxContainerBase::getWritableAuxIDs() const {
 
      // Return the full list of known IDs. The constness of this object's
      // members comes from the object being const or not.
      return m_auxids;
   }
 
   bool AuxContainerBase::resize( size_t size ) {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // This operation is not allowed on a locked container:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "resize" );
      }
 
      // Do the operation on the static variables:
      bool nomoves = true;
      for (SG::IAuxTypeVector* v : m_vecs) {
         if(v && !v->isLinked()) {
           if (!v->resize( size ))
             nomoves = false;
         }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
        if (!m_store->resize( size ))
          nomoves = false;
      }
 
      return nomoves;
   }
 
   void AuxContainerBase::reserve( size_t size ) {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // This operation is not allowed on a locked container:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "reserve" );
      }
 
      // Do the operation on the static variables:
      for (SG::IAuxTypeVector* v : m_vecs) {
         if(v && !v->isLinked()) {
            v->reserve( size );
         }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
         m_store->reserve( size );
      }
 
      return;
   }
 
   void AuxContainerBase::shift( size_t pos, ptrdiff_t offs ) {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // This operation is not allowed on a locked container:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "shift" );
      }
 
      // Do the operation on the static variables:
      for (SG::IAuxTypeVector* v : m_vecs) {
         if(v && !v->isLinked()) {
            v->shift( pos, offs );
         }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
         m_store->shift( pos, offs );
      }
 
      return;
   }
 
 
   bool AuxContainerBase::insertMove( size_t pos,
                                      IAuxStore& other,
                                      const SG::auxid_set_t& ignore_in ) {
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // This operation is not allowed on a locked container:
      if( m_locked ) {
         throw SG::ExcStoreLocked( "insertMove" );
      }
 
      bool nomove = true;
      size_t other_size = other.size();
 
      SG::auxid_set_t ignore = ignore_in;
      
      // Do the operation on the static variables:
      for (SG::auxid_t id : m_auxids) {
        SG::IAuxTypeVector* v_dst = nullptr;
        if (id < m_vecs.size())
          v_dst = m_vecs[id];
        // Skip linked vars --- they should be taken care of by the parent var.
        if (v_dst && !v_dst->isLinked()) {
          ignore.insert (id);
          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;
          }
        }
      }
 
      // Do the operation on the dynamic variables:
      if( m_store ) {
        if (!m_store->insertMove( pos, other, ignore ))
          nomove = false;
 
        // Notice any new variables added as a result of this.
        m_auxids.insert (m_store->getAuxIDs());
      }
 
      return nomove;
   }
 
 
   bool AuxContainerBase::setOption( auxid_t id,
                                     const SG::AuxDataOption& option ) {
 
      guard_t guard (m_mutex);
      if (id < m_vecs.size() && m_vecs[id] != nullptr)
         return m_vecs[id]->setOption (option);
 
      if (m_store)
         return m_store->setOption (id, option);
      return false;
   }
 
 
   //
 
   //
   //           Implementation of the SG::IAuxStoreIO functions
   //
 
   const void* AuxContainerBase::getIOData( auxid_t auxid ) const {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // If the variable is not static, look for it in the dynamic store:
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         if( m_storeIO ) {
            return m_storeIO->getIOData( auxid );
         } else {
            std::cout << "ERROR xAOD::AuxContainerBase::getIOData "
                      << "Unknown variable ("
                      << SG::AuxTypeRegistry::instance().getName( auxid )
                      << ") requested" << std::endl;
            return nullptr;
         }
      }
 
      // Update the statistics for this variable. The dynamic store registers
      // its own variable accesses.
      IOStats::instance().stats().readBranch( m_name, auxid );
 
      return m_vecs[ auxid ]->toVector();
   }
 
   const std::type_info* AuxContainerBase::getIOType( auxid_t auxid ) const {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // If the variable is not static, ask the dynamic store:
      if( ( auxid >= m_vecs.size() ) || ( ! m_vecs[ auxid ] ) ) {
         if( m_storeIO ) {
            return m_storeIO->getIOType( auxid );
         }
      }
 
      // Fall back on getting the information from the registry:
      return SG::AuxTypeRegistry::instance().getVecType( auxid );
   }
 
   const AuxContainerBase::auxid_set_t&
   AuxContainerBase::getDynamicAuxIDs() const {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // All the variables handled by the internal store are dynamic
      // if such a store exists:
      if( m_storeIO ) {
         // I mean, all the variables. Not just the ones reported as dynamic
         // by the internal object. Because the internal object may be something
         // that was put into this one in order to achieve data slimming.
         return m_store->getAuxIDs();
      }
      // In case we don't use an internal store, there are no dynamic
      // variables:
      static const auxid_set_t dummy (0);
      return dummy;
   }
 
   AuxContainerBase::auxid_set_t
   AuxContainerBase::getSelectedAuxIDs() const {
 
      // Guard against multi-threaded execution:
      guard_t guard( m_mutex );
 
      // All the variables handled by the internal store are dynamic
      // if such a store exists:
      if( m_storeIO ) {
         // I mean, all the variables. Not just the ones reported as dynamic
         // by the internal object. Because the internal object may be something
         // that was put into this one in order to achieve data slimming.
         return m_store->getAuxIDs();
      }
 
      // In case we don't use an internal store, there are no dynamic
      // variables:
      return auxid_set_t();
   }
 
   //
 
   const char* AuxContainerBase::name() const {
 
      return m_name.c_str();
   }
 
   void AuxContainerBase::setName( const char* name ) {
 
      m_name = name;
      return;
   }
 
} // namespace xAOD