StoreGateSvc.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#include "GaudiKernel/IIncidentSvc.h"
#include "AthenaKernel/errorcheck.h"
#include "StoreGate/StoreClearedIncident.h"
#include "AthAllocators/ArenaHeader.h"
 
#include "StoreGate/StoreGateSvc.h"
#include "StoreGate/tools/SGImplSvc.h"
#include "SGTools/DataStore.h"
 
#include "Gaudi/Interfaces/IOptionsSvc.h"
#include "GaudiKernel/IAppMgrUI.h"
#include <fstream>
#include <print>
#include <algorithm>
 
using namespace SG;
using namespace std;
 
namespace {
    thread_local HiveEventSlot* currentHiveEventSlot = nullptr;
    thread_local StoreGateSvc* currentStoreGate = nullptr;
}

StoreGateSvc::StoreGateSvc(const std::string& name,ISvcLocator* svc) : 
  base_class(name,svc),
  m_storeID (StoreID::findStoreID(name))
{
}
 
StoreGateSvc::~StoreGateSvc()  
{}

StatusCode
StoreGateSvc::retrieve(CLID id,
                       SG::TypelessIterator& begin,
                       SG::TypelessIterator& end) const {
  if (m_storeID == StoreID::EVENT_STORE && currentSlot() != nullptr) {
    rememberBadRetrieve (id, "(iterator)");
  }
  _SGXCALL(retrieve, (id, begin, end), StatusCode::FAILURE);
}
 
void 
StoreGateSvc::setDefaultStore(SGImplSvc* pStore) {
  m_defaultStore = pStore;
}
 
void 
StoreGateSvc::setSlot(SG::HiveEventSlot* pSlot) { 
  currentHiveEventSlot=pSlot;
  if ( 0 != currentHiveEventSlot) {
    currentHiveEventSlot->pEvtStore->makeCurrent();
  }
}
 
StoreGateSvc *StoreGateSvc::currentStoreGate() {
  if (!::currentStoreGate) {
    // this is a static function so we don't have many conveniences
    ISvcLocator *svcLocator = Gaudi::svcLocator();
    SmartIF<StoreGateSvc> sg{svcLocator->service("StoreGateSvc/StoreGateSvc")};
    if ( !sg.isValid() ) {
      throw GaudiException(
          "Could not get \"StoreGateSvc\" to initialize currentStoreGate",
          "StoreGateSvc", StatusCode::FAILURE);
    }
    sg->makeCurrent();
    return sg;
  }
  return ::currentStoreGate;
}
 
SG::HiveEventSlot*
StoreGateSvc::currentSlot() { 
  return currentHiveEventSlot; 
}

 
 
void
StoreGateSvc::commitNewDataObjects() {
  _SGVOIDCALL(commitNewDataObjects, ());
}

StatusCode 
StoreGateSvc::recordAddress(const std::string& skey,
                            CxxUtils::RefCountedPtr<IOpaqueAddress> pAddress,
                            bool clearAddressFlag,
                            const std::vector<CLID>& bases)
{
  _SGXCALL(recordAddress, (skey, std::move(pAddress), clearAddressFlag, bases), StatusCode::FAILURE);
}

StatusCode 
StoreGateSvc::recordAddress(CxxUtils::RefCountedPtr<IOpaqueAddress> pAddress,
                            bool clearAddressFlag,
                            const std::vector<CLID>& bases)
{
  _SGXCALL(recordAddress, (std::move(pAddress), clearAddressFlag, bases), StatusCode::FAILURE);
}
 
 
StatusCode 
StoreGateSvc::setConst(const void* pObject) {
  _SGXCALL(setConst, (pObject), StatusCode::FAILURE);
}
 

StatusCode StoreGateSvc::initialize()    {
 
  // Initialize service:
  CHECK( Service::initialize() );
 
  SG_MSG_VERBOSE ("Initializing {}", name());
 
  SmartIF<Gaudi::Interfaces::IOptionsSvc> pJOSvc{serviceLocator()->service("JobOptionsSvc")};
  if ( !pJOSvc.isValid() ) {
    SG_MSG_ERROR ("Failed to retrieve JobOptionsSvc");
  }
  //copy our properties to the prototype (default) SGImplSvc
  const std::string implStoreName = name() + "_Impl";
  for (const Gaudi::Details::PropertyBase* p : getProperties()) {
    pJOSvc->set( implStoreName + "." + p->name(), p->toString() );
  }
 
  //HACK ALERT: using createService rather then the customary service(...,CREATEIF=true) we set our pointer
  // to SGImplSvc early (even before it is initialized). This should help take care of some initialize loops
  // for example when we try to record an address from one of the address providers initialize methods
 
  std::string implStoreFullName = "SGImplSvc/" + implStoreName;
  SG_MSG_DEBUG ("trying to create store {}", implStoreFullName);
  
  m_defaultStore = serviceLocator().as<ISvcManager>()->createService(implStoreFullName);
 
  if (!m_defaultStore) {
    SG_MSG_ERROR ("Could not create store {}", implStoreFullName);
    return StatusCode::FAILURE;
  }
  
  if ( m_defaultStore->sysInitialize().isSuccess() ) {
    // If this is the default event store (StoreGateSvc), then declare
    // our arena as the default for memory allocations.
    if (name()  == "StoreGateSvc") {
      m_defaultStore->makeCurrent();
    }
  } else {
    SG_MSG_ERROR ("Could not initialize default store {}", implStoreFullName);
    return StatusCode::FAILURE;
  }
  if ( !m_incSvc.retrieve().isSuccess() ) {
    SG_MSG_ERROR ("Could not locate IncidentSvc");
    return StatusCode::FAILURE;
  }
 
  // Don't retrieve m_activeStoreSvc here to prevent a possible
  // initialization loop.
 
  if (m_DumpStore) {
    const int PRIORITY=100;
    m_incSvc->addListener(this, "EndEvent",PRIORITY);
  }
 
  return StatusCode::SUCCESS;
}

StatusCode StoreGateSvc::stop()    {
  SG_MSG_VERBOSE ("Stop {}", name());
  //HACK ALERT: ID event store objects refer to det store objects
  //by setting an ad-hoc priority for event store(s) we make sure they are finalized and hence cleared first
  // see e.g. https://savannah.cern.ch/bugs/index.php?99993
  if (m_defaultStore->store()->storeID() == StoreID::EVENT_STORE) {
    auto pISM = serviceLocator().as<ISvcManager>();
    pISM->setPriority(name(), pISM->getPriority(name())+1).ignore();
    SG_MSG_VERBOSE ("stop: setting service priority to {} so that event stores get finalized and cleared before other stores",
                    pISM->getPriority(name()));
  }
  return StatusCode::SUCCESS;
}
 
void StoreGateSvc::handle(const Incident &inc) {
  currentStore()->handle(inc);
}

 
StatusCode
StoreGateSvc::finalize() {
  CHECK( Service::finalize() );
  SG_MSG_VERBOSE ("Finalizing {}", name());
  if (m_defaultStore) {
    // m_defaultStore is not active, so ServiceManager won't finalize it!
    CHECK( m_defaultStore->finalize());
  }
 
  printBadList (m_badRetrieves, "retrieve()");
  printBadList (m_badRecords,   "record()");
  return StatusCode::SUCCESS;
}
 

DataProxy* 
StoreGateSvc::proxy(const void* const pTransient) const {
  _SGXCALL(proxy, (pTransient), 0);
}

DataProxy* 
StoreGateSvc::proxy(const CLID& id) const {
  _SGXCALL(proxy, (id), 0);
}

DataProxy* 
StoreGateSvc::proxy(const CLID& id, const std::string& key) const { 
  _SGXCALL(proxy, (id, key), 0);
}
 

SG::DataProxy* 
StoreGateSvc::proxy(const CLID& id, bool checkValid) const {
  _SGXCALL(proxy, (id, checkValid), 0);
}

SG::DataProxy* 
StoreGateSvc::proxy(const CLID& id, const std::string& key, bool checkValid) const {
  _SGXCALL(proxy, (id, key, checkValid), 0);
}
 

StatusCode StoreGateSvc::addToStore (CLID id, SG::DataProxy* proxy)
{
  _SGXCALL(addToStore,  (id, proxy), StatusCode::FAILURE);
}
 

SG::DataProxy*
StoreGateSvc::recordObject (SG::DataObjectSharedPtr<DataObject> obj,
                            const std::string& key,
                            bool allowMods,
                            bool returnExisting)
{
  _SGXCALL(recordObject, (std::move(obj), key, allowMods, returnExisting), nullptr);
}
 

vector<const SG::DataProxy*> 
StoreGateSvc::proxies() const {
  vector<const SG::DataProxy*> nullV;
  _SGXCALL(proxies, (), nullV);
}

vector<CLID> 
StoreGateSvc::clids() const
{
  vector<CLID> nullV;
  _SGXCALL(clids, (), nullV);
}

SG::DataProxy* 
StoreGateSvc::transientProxy(const CLID& id, const std::string& key) const {
  _SGXCALL(transientProxy, (id, key), 0);
}
 

DataObject* 
StoreGateSvc::accessData(const CLID& id) const {
  _SGXCALL(accessData, (id), 0);
}

DataObject* 
StoreGateSvc::accessData(const CLID& id, const std::string& key) const {
  _SGXCALL(accessData, (id, key), 0);
}
 
bool
StoreGateSvc::transientSwap( const CLID& id,
                             const std::string& keyA, const std::string& keyB ) {
  _SGXCALL(transientSwap, (id, keyA, keyB), false);
}

StatusCode 
StoreGateSvc::typeless_record( DataObject* obj, const std::string& key,
                               const void* const raw_ptr,
                               bool allowMods, bool resetOnly,
                               bool noHist ) {
  _SGXCALL(typeless_record, (obj, key, raw_ptr, allowMods, resetOnly, noHist), StatusCode::FAILURE);
}

StatusCode 
StoreGateSvc::typeless_overwrite( const CLID& id,
                                  DataObject* obj, const std::string& key,
                                  const void* const raw_ptr,
                                  bool allowMods,
                                  bool noHist,
                                  const std::type_info* tinfo) {
  _SGXCALL(typeless_overwrite, (id, obj, key, raw_ptr, allowMods, noHist, tinfo), StatusCode::FAILURE);
}

void 
StoreGateSvc::setStoreID(StoreID::type id)
{
  m_storeID = id;
  // FIXME: should broadcast this to all instances.
  _SGVOIDCALL(setStoreID,(id));
}
 
void
StoreGateSvc::keys(const CLID& id, std::vector<std::string>& vkeys, 
                   bool includeAlias, bool onlyValid) const
{ 
  _SGVOIDCALL(keys,(id, vkeys, includeAlias, onlyValid));
} 
 
 
 
std::string 
StoreGateSvc::dump() const {
  std::string nullS = "\n>>>>>>>NO CURRENT STORE<<<<<<<\n";
  _SGXCALL(dump, (), nullS);  
}
 
int
StoreGateSvc::typeCount(const CLID& clid) const{
  _SGXCALL(typeCount, (clid), -1);
}
 
 
 
typename StoreGateSvc::sgkey_t 
StoreGateSvc::stringToKey (const std::string& str, CLID clid) {
  _SGXCALL( stringToKey, (str, clid), 0 );
}
 
const std::string* 
StoreGateSvc::keyToString (sgkey_t key) const {
  _SGXCALL( keyToString, (key), 0 );
}
 
const std::string* 
StoreGateSvc::keyToString (sgkey_t key, CLID& clid) const {
  _SGXCALL( keyToString, (key, clid), 0 );
}
 
void 
StoreGateSvc::registerKey (sgkey_t key,
                           const std::string& str,
                           CLID clidid) {
  _SGVOIDCALL( registerKey, (key, str, clidid) );
}
void 
StoreGateSvc::remap_impl (sgkey_t source,
                          sgkey_t target,
                          off_t index_offset) {
  _SGVOIDCALL( remap_impl, (source, target, index_offset) );
}
 
bool 
StoreGateSvc::tryELRemap (sgkey_t sgkey_in, size_t index_in,
                          sgkey_t& sgkey_out, size_t& index_out) {
  _SGXCALL( tryELRemap, (sgkey_in, index_in, sgkey_out, index_out), false );
}
 
void 
StoreGateSvc::releaseObject(const CLID& id, const std::string& key) {
  _SGVOIDCALL( releaseObject, (id, key) );
}
 
void 
StoreGateSvc::clearProxyPayload(SG::DataProxy* proxy) {
  _SGVOIDCALL( clearProxyPayload, (proxy) );
}
 
 
StatusCode 
StoreGateSvc::loadEventProxies() {
  this->makeCurrent();
  _SGXCALL(loadEventProxies, (), StatusCode::FAILURE);
}

// clear store
StatusCode 
StoreGateSvc::clearStore(bool forceRemove)
{
  StatusCode sc = currentStore()->clearStore(forceRemove);
 
  // See if we want to send a ClearStore incident.
  // If m_pruneIncidents is true then we check the first time
  // to see if there are any listeners.  If not, then we avoid
  // sending these incidents for the rest of the job.
  if (m_pruneIncidents) {
    if (m_listenerState == UNCHECKED) {
      std::vector<IIncidentListener*> l;
      m_incSvc->getListeners (l, "StoreCleared");
      m_listenerState = l.empty() ? NO_LISTENERS : HAVE_LISTENERS;
    }
    if (m_listenerState == NO_LISTENERS) {
      return sc;
    }
  }
 
  // Send a notification that the store was cleared.
  if (sc.isSuccess()) {
    m_incSvc->fireIncident(StoreClearedIncident (this, name()));
  }
  return sc;
}
 
void
StoreGateSvc::emptyTrash() {
  _SGVOIDCALL( emptyTrash, () );
}

void StoreGateSvc::makeCurrent() {
  ::currentStoreGate = this;
  _SGVOIDCALL (makeCurrent, ());
}
 
StatusCode StoreGateSvc::removeProxy(SG::DataProxy* proxy, const void* pTrans, 
                                     bool forceRemove) {
  _SGXCALL(removeProxy, (proxy, pTrans, forceRemove), StatusCode::FAILURE);
}
 

StatusCode
StoreGateSvc::createObj (IConverter* cvt,
                         IOpaqueAddress* addr,
                         DataObject*& refpObject)
{
  _SGXCALL( createObj, (cvt, addr, refpObject), StatusCode::FAILURE );
}
 

void StoreGateSvc::rememberBad (BadItemList& bad,
                                CLID clid, const std::string& key) const
{
  if (m_storeID == StoreID::EVENT_STORE && currentHiveEventSlot != nullptr) {
    lock_t lock (m_badMutex);
    std::string algo;
    if (m_algContextSvc.isValid()) {
      if (IAlgorithm* alg = m_algContextSvc->currentAlg()) {
        if (alg->type() == "AthenaOutputStream") return;
        if (alg->type() == "AthIncFirerAlg") return;
        algo = alg->type() + "/" + alg->name();
        bad.insert (BadListItem (clid, key, algo));
      }
    }
  }
}
 

void StoreGateSvc::printBadList (const BadItemList& bad,
                                 const std::string& what) const
{
  if (bad.empty()) return;
  std::vector<std::string> lines;
  for (const BadListItem& id : bad) {
    lines.push_back (id.fullKey() + " [" + id.m_algo + "]");
  }
  std::sort (lines.begin(), lines.end());
  SG_MSG_WARNING ("Called {} on these objects in a MT store", what);
  for (const std::string& s : lines) {
    SG_MSG_WARNING (s);
  }
}
 
 
void SG_dump (StoreGateSvc* sg)
{
  std::println ("{}", sg->dump());
}
 
void SG_dump (StoreGateSvc* sg, const char* fname)
{
  std::ofstream f (fname);
  std::println (f, "{}", sg->dump());
  f.close();
}