IOVSvcTool Class Reference

#include <IOVSvcTool.h>

Inheritance diagram for IOVSvcTool:

Public Member Functions
	IOVSvcTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual StatusCode	initialize () override
virtual void	handle (const Incident &) override
virtual void	setStoreName (const std::string &storeName) override
virtual const std::string &	getStoreName () const override
virtual StatusCode	setRange (const CLID &clid, const std::string &key, IOVRange &) override
virtual StatusCode	getRange (const CLID &clid, const std::string &key, IOVRange &iov) const override
virtual StatusCode	regProxy (SG::DataProxy *proxy, const std::string &key) override
	Register a DataProxy with the service.
virtual StatusCode	regProxy (const CLID &clid, const std::string &key) override
	Register a DataProxy with the service.
virtual StatusCode	deregProxy (SG::DataProxy *proxy) override
	Deregister a DataProxy with the service.
virtual StatusCode	deregProxy (const CLID &clid, const std::string &key) override
	Deregister a DataProxy with the service.
virtual StatusCode	replaceProxy (SG::DataProxy *pOld, SG::DataProxy *pNew) override
	replace a registered DataProxy with a new version
virtual StatusCode	getRangeFromDB (const CLID &clid, const std::string &key, IOVRange &range, std::string &tag, std::unique_ptr< IOpaqueAddress > &ioa, const IOVTime &curTime) const override
virtual StatusCode	getRangeFromDB (const CLID &clid, const std::string &key, const IOVTime &time, IOVRange &range, std::string &tag, std::unique_ptr< IOpaqueAddress > &ioa) const override
virtual StatusCode	setRangeInDB (const CLID &clid, const std::string &key, const IOVRange &range, const std::string &tag) override
virtual StatusCode	preLoadTAD (const SG::TransientAddress *) override
	add to a set of TADs that will be registered at start of first event
virtual StatusCode	preLoadDataTAD (const SG::TransientAddress *) override
	add to a set of TADs that who's data will be preLoaded
virtual bool	holdsProxy (SG::DataProxy *proxy) const override
virtual bool	holdsProxy (const CLID &clid, const std::string &key) const override
virtual void	resetAllProxies () override
virtual void	ignoreProxy (const CLID &clid, const std::string &key) override
virtual void	ignoreProxy (SG::DataProxy *proxy) override

Private Types
typedef std::tuple< CLID, std::string >	TADkey_t

Private Member Functions
StatusCode	preLoadProxies (const EventContext &ctx)
StatusCode	preLoadData ()
std::string	fullProxyName (const SG::TransientAddress *) const
std::string	fullProxyName (const SG::DataProxy *) const
std::string	fullProxyName (const CLID &, const std::string &) const
void	setRange_impl (SG::DataProxy *proxy, IOVRange &iovr)
TADkey_t	TADkey (const SG::DataProxy &p)
TADkey_t	TADkey (const SG::TransientAddress &t)
void	scanStartSet (IOVEntry::StartSet_t &pSet, const std::string &type, std::set< SG::DataProxy *, SortDPptr > &proxiesToReset, const IOVTime &curTime) const
void	scanStopSet (IOVEntry::StopSet_t &pSet, const std::string &type, std::set< SG::DataProxy *, SortDPptr > &proxiesToReset, const IOVTime &curTime) const
void	PrintStartSet () const
void	PrintStopSet () const
void	PrintProxyMap () const
void	PrintProxyMap (const SG::DataProxy *) const

Private Attributes
std::string	m_storeName
ServiceHandle< StoreGateSvc >	p_cndSvc
ServiceHandle< IIncidentSvc >	p_incSvc
ServiceHandle< IProxyProviderSvc >	p_PPSvc
ServiceHandle< IClassIDSvc >	p_CLIDSvc
ServiceHandle< IToolSvc >	p_toolSvc
std::map< const SG::DataProxy *, std::string >	m_names
std::recursive_mutex m_handleMutex	ATLAS_THREAD_SAFE
std::set< SG::DataProxy *, SortDPptr >	m_proxies
std::set< SG::DataProxy * >	m_ignoredProxies
std::set< std::pair< CLID, std::string > >	m_ignoredProxyNames
std::map< const SG::DataProxy *, std::unique_ptr< IOVEntry > >	m_entries
IOVEntry::StartSet_t *	p_startSet {nullptr}
IOVEntry::StopSet_t *	p_stopSet {nullptr}
IOVEntry::StartSet_t	m_startSet_Clock
IOVEntry::StartSet_t	m_startSet_RE
IOVEntry::StopSet_t	m_stopSet_Clock
IOVEntry::StopSet_t	m_stopSet_RE
std::set< std::unique_ptr< const SG::TransientAddress >, SortTADptr >	m_preLoad
std::set< TADkey_t >	m_partPreLoad
std::atomic< bool >	m_first {true}
bool	m_checkOnce {false}
bool	m_firstEventOfRun {false}
std::string	m_checkTrigger
Gaudi::Property< bool >	m_preLoadRanges {this, "preLoadRanges", false}
Gaudi::Property< bool >	m_preLoadData {this, "preLoadData", false}
Gaudi::Property< bool >	m_partialPreLoadData {this, "partialPreLoadData", true}
Gaudi::Property< bool >	m_preLoadExtensibleFolders {this, "preLoadExtensibleFolders", true}
Gaudi::Property< bool >	m_sortKeys {this, "sortKeys", true}
Gaudi::Property< bool >	m_forceReset {this, "forceResetAtBeginRun", false}
Gaudi::Property< std::string >	m_updateInterval {this, "updateInterval", "Event"}

Detailed Description

Definition at line 67 of file IOVSvcTool.h.

Member Typedef Documentation

TADkey_t

typedef std::tuple<CLID, std::string> IOVSvcTool::TADkey_t

private

Definition at line 189 of file IOVSvcTool.h.

Constructor & Destructor Documentation

IOVSvcTool()

IOVSvcTool::IOVSvcTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 70 of file IOVSvcTool.cxx.

                                                : 
  base_class( type, name, parent ),
  m_storeName("StoreGateSvc"), 
  p_cndSvc("DetectorStore",name),
  p_incSvc("IncidentSvc",name), p_PPSvc("ProxyProviderSvc",name),
  p_CLIDSvc("ClassIDSvc",name), p_toolSvc("ToolSvc",name)
{
}

Member Function Documentation

deregProxy() [1/2]

StatusCode IOVSvcTool::deregProxy ( const CLID & clid, const std::string & key )

overridevirtual

Deregister a DataProxy with the service.

Definition at line 558 of file IOVSvcTool.cxx.

                                                               {
 
  SG::DataProxy* proxy = p_cndSvc->proxy(clid,key);
 
  if (proxy == nullptr) {
    ATH_MSG_ERROR("regProxy could not retrieve proxy "
                  << fullProxyName(clid,key) << " from store");
    return StatusCode::FAILURE;
  }
 
  return ( deregProxy(proxy) );
 
}

deregProxy() [2/2]

StatusCode IOVSvcTool::deregProxy ( SG::DataProxy * proxy )

overridevirtual

Deregister a DataProxy with the service.

Definition at line 440 of file IOVSvcTool.cxx.

                                          {
 
 
  if (proxy == nullptr) {
    ATH_MSG_ERROR("proxy == 0");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG("removing proxy " << fullProxyName(proxy) << " at " << proxy);
 
  const auto itr = m_proxies.find(proxy);
  if (itr == m_proxies.end()) {
    ATH_MSG_DEBUG("Proxy for " << fullProxyName(proxy)
                  << " not registered: " << proxy->name());
    return StatusCode::SUCCESS;
  }
 
  m_proxies.erase( itr );
 
  return StatusCode::SUCCESS;
 
}

fullProxyName() [1/3]

std::string IOVSvcTool::fullProxyName ( const CLID & clid, const std::string & key ) const

private

Definition at line 1084 of file IOVSvcTool.cxx.

                                                                        {
 
  std::string fullname, tname;
  if (p_CLIDSvc->getTypeNameOfID( clid, tname ).isFailure()) {
    fullname = "[";
    fullname += std::to_string(clid);
    fullname += '/';
    fullname += key;
    fullname += ']';
  } else {
    fullname = "[";
    fullname += tname;
    fullname += ':';
    fullname += std::to_string(clid);
    fullname += '/';
    fullname += key;
    fullname += ']';
  }
 
  return fullname;
}

fullProxyName() [2/3]

std::string IOVSvcTool::fullProxyName ( const SG::DataProxy * dp ) const

private

Definition at line 1077 of file IOVSvcTool.cxx.

                                                       {
  return fullProxyName(dp->clID(), dp->name());
}

fullProxyName() [3/3]

std::string IOVSvcTool::fullProxyName ( const SG::TransientAddress * tad ) const

private

Definition at line 1068 of file IOVSvcTool.cxx.

                                                               {
 
  return fullProxyName(tad->clID(), tad->name());
 
}

getRange()

StatusCode IOVSvcTool::getRange ( const CLID & clid, const std::string & key, IOVRange & iov ) const

overridevirtual

Definition at line 707 of file IOVSvcTool.cxx.

                                          {
 
  SG::DataProxy* dp = p_cndSvc->proxy(clid,key);
 
  std::scoped_lock lock(m_handleMutex);
  const auto itr = m_entries.find(dp);
  if (itr == m_entries.end()) {
    return StatusCode::FAILURE;
  }
 
  iov = *(itr->second->range());
 
  return StatusCode::SUCCESS;
 
}

getRangeFromDB() [1/2]

StatusCode IOVSvcTool::getRangeFromDB ( const CLID & clid, const std::string & key, const IOVTime & time, IOVRange & range, std::string & tag, std::unique_ptr< IOpaqueAddress > & ioa ) const

overridevirtual

Definition at line 744 of file IOVSvcTool.cxx.

                                                                     {
  StatusCode sc(StatusCode::FAILURE);
  SG::DataProxy* dp = p_cndSvc->proxy(clid,key);
  if (nullptr != dp) {
    IIOVDbSvc *idb = 
      dynamic_cast<IIOVDbSvc*>(dp->provider());
    if (idb != nullptr) {
      sc = idb->getRange(clid, key, time, range, tag, ioa);
    } else {
      ATH_MSG_ERROR("Provider is not an IIOVDbSvc");
    }
  } else {
    ATH_MSG_ERROR("No proxy found for clid " << clid << " key " << key);
  }
  return sc;
}

getRangeFromDB() [2/2]

StatusCode IOVSvcTool::getRangeFromDB ( const CLID & clid, const std::string & key, IOVRange & range, std::string & tag, std::unique_ptr< IOpaqueAddress > & ioa, const IOVTime & curTime ) const

overridevirtual

Definition at line 727 of file IOVSvcTool.cxx.

                                             {
 
  if (curTime.isValid()) {
    return getRangeFromDB(clid, key, curTime, range, tag, ioa);
  } else {
    ATH_MSG_ERROR("Current Event not defined");
    return StatusCode::FAILURE;
  }
 
}

getStoreName()

virtual const std::string & IOVSvcTool::getStoreName ( ) const

inlineoverridevirtual

Definition at line 87 of file IOVSvcTool.h.

{ return m_storeName; }

handle()

void IOVSvcTool::handle ( const Incident & inc )

overridevirtual

Read in the next set of IOVRanges

Definition at line 153 of file IOVSvcTool.cxx.

                                      {
 
  bool initial_first = m_first;
 
  // Don't bother doing anything if we're handled the first run, and
  // preLoadData has been set, or if we only want to check once at the
  // beginning of the job
  if (!initial_first && m_preLoadData && m_checkOnce) {
    return;
  }
  else if (!initial_first) {
     if ( inc.type() != m_checkTrigger && inc.type() != IncidentType::BeginRun ) {
        return;
     }
  }
 
  std::scoped_lock lock(m_handleMutex);
  if (initial_first) {
     if (!m_first && m_preLoadData && m_checkOnce) {
        return;
     }
     // cppcheck-suppress oppositeInnerCondition
     else if (!m_first) {
        if ( inc.type() != m_checkTrigger && inc.type() != IncidentType::BeginRun ) {
           return;
        }
     }
     // cppcheck-suppress identicalInnerCondition
     if (m_first) {
        for (const auto& e : m_ignoredProxyNames) {
          SG::DataProxy* proxy = p_cndSvc->proxy(e.first,e.second);
           ATH_MSG_DEBUG("retrieving "<<fullProxyName(e.first,e.second));
           if (proxy == nullptr) {
              ATH_MSG_ERROR("ignoreProxy: could not retrieve proxy "
                            << fullProxyName(e.first,e.second) << " from store");
           } else {
              ignoreProxy( proxy );
              ATH_MSG_DEBUG("will ignore resetting proxy " << fullProxyName(proxy));
           }
        }
        m_first = false;
     }
     else {
        initial_first=false;
     }
  }//end first
  const bool first = initial_first;
 
  // Forcing IOV checks on the first event in the run for AthenaMP (ATEAM-439)
  if(Gaudi::Concurrency::ConcurrencyFlags::numProcs()==0) {
    if (inc.type() == IncidentType::BeginRun) {
      m_firstEventOfRun = true;
    }
 
    if (inc.type() == IncidentType::BeginEvent && m_firstEventOfRun) {
      m_firstEventOfRun = false;
      if (m_checkTrigger == "BeginEvent") {
    return;
      }
    }
  }
 
  std::set< SG::DataProxy*, SortDPptr > proxiesToReset;
  if ( inc.type() == m_checkTrigger || inc.type() == IncidentType::BeginRun ) {
 
    const EventIDBase& eventID = inc.context().eventID();
    const uint32_t event = eventID.lumi_block();
    const uint32_t run   = eventID.run_number();
    
    ATH_MSG_DEBUG("Got event info: " << "run="<< run << ", event=" << event);
 
    IOVTime curTime;
    curTime.setRunEvent(run,event);
    // get ns timestamp from event
    curTime.setTimestamp(1000000000L*(uint64_t)eventID.time_stamp() + eventID.time_stamp_ns_offset());
 
    if (msgLvl(MSG::DEBUG)) {
      msg().setColor(MSG::YELLOW,MSG::RED);
      msg() << inc.type() << ": [R/LB] = " << curTime << endmsg;
    }
 
    if (inc.type() == IncidentType::BeginRun) {
      // Signal BeginRun directly to IOVDbSvc
      SmartIF<IIOVDbSvc> iovDB{service("IOVDbSvc", false)};
      if (!iovDB) {
        ATH_MSG_DEBUG("Unable to get the IOVDbSvc");
        return;
      }
      if (StatusCode::SUCCESS != iovDB->signalBeginRun(curTime,
                                                       inc.context()))
      {
        ATH_MSG_ERROR("Unable to signal begin run to IOVDbSvc");
        return;
      }
      else {
        ATH_MSG_DEBUG("Signaled begin run to IOVDbSvc " << curTime);
      }
    }
    
    if (first) {
 
      for (const auto& tad : m_preLoad) {
        StatusCode sc = regProxy(tad->clID(), tad->name());
        if (StatusCode::SUCCESS != sc) {
          ATH_MSG_ERROR("handle: Could not register proxy for " <<
                        fullProxyName(tad->clID(), tad->name()));
          return;
        }
      }
 
      if (msgLvl(MSG::VERBOSE)) {
        PrintProxyMap();
        msg() << endmsg;
      }
 
      // preLoad the ranges and data if requested.
      if (preLoadProxies(inc.context()).isFailure()) {
        ATH_MSG_ERROR("Problems preloading IOVRanges");
        throw( std::runtime_error("IOVSvcTool::preLoadProxies") );
      }
 
      // Signal EndProxyPreload directly to IOVDbSvc
      SmartIF<IIOVDbSvc> iovDB{service("IOVDbSvc", false)};
      if (iovDB) {
        iovDB->signalEndProxyPreload();
        ATH_MSG_DEBUG("Signaled end proxy preload to IOVDbSvc " << curTime);
      }
    }// end if first
    
    // If preLoadData has been set, never check validity of data again.
    if (m_preLoadData && m_checkOnce) {
      return;
    }
 
    // Otherwise, do the normal check for validity
 
 
    if (msgLvl(MSG::DEBUG)) {
      PrintStartSet();
      PrintStopSet();
      msg() << endmsg;
    }
    
    //
    //
 
    if (inc.type() == IncidentType::BeginRun && m_forceReset && !s_firstRun) {
 
      ATH_MSG_DEBUG("Resetting all proxies on BeginRun incident for store \""
                    << m_storeName << "\"");
 
      if (msgLvl(MSG::VERBOSE)) {
        for (SG::DataProxy* p : m_proxies) {
          msg() << "   " << m_names.at(p) << std::endl;
        }
        msg() << endmsg;
      }
      proxiesToReset = m_proxies;
    } else {
      scanStartSet(m_startSet_Clock,"(ClockTime)",proxiesToReset,curTime);
      scanStartSet(m_startSet_RE,"(R/E)",proxiesToReset,curTime);
 
      scanStopSet(m_stopSet_Clock,"(ClockTime)",proxiesToReset,curTime);
      scanStopSet(m_stopSet_RE,"(R/E)",proxiesToReset,curTime);
    }
 
    for (SG::DataProxy* p : m_ignoredProxies) {
      auto itr = proxiesToReset.find(p);
      if (itr != proxiesToReset.end()) {
        proxiesToReset.erase( itr );
      }
    }
 
    // If MT, must not call any callback functions after first event
    if (!first && !proxiesToReset.empty() &&
        ( (Gaudi::Concurrency::ConcurrencyFlags::numThreads() +
           Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents()) > 0 ) ) {
      ATH_MSG_FATAL("Cannot update Conditions via callback functions in MT after the first event");
      for (const SG::DataProxy* prox : proxiesToReset) {
        ATH_MSG_FATAL("CLID=" << prox->clID() << ", name=" << prox->name());
      }
      throw GaudiException("Cannot update Conditions via callback functions in MT after the first event",name(),StatusCode::FAILURE);
    }
 
    //
    //
    for (SG::DataProxy* prx : proxiesToReset) {
      ATH_MSG_VERBOSE("clearing proxy payload for " << m_names.at(prx));
 
      // Reset proxy
      
      p_cndSvc->clearProxyPayload( prx );
 
      // Load data if preload requested.
 
      if ( (m_partialPreLoadData && 
            m_partPreLoad.contains(TADkey(*prx)) )
           ||
           m_preLoadData ) {       
        ATH_MSG_VERBOSE("preloading data");
 
        Gaudi::Guards::AuditorGuard auditor(m_names.at(prx), auditorSvc(), "preLoadProxy");
        if (prx->accessData() == nullptr) {
          ATH_MSG_ERROR("problems preloading data for " << m_names.at(prx));
        }
      }
 
    }

    for (SG::DataProxy* prx : proxiesToReset) {
      const auto pitr = m_entries.find( prx );
      if ( pitr != m_entries.end() && pitr->second->range()->isInRange(curTime) ) {
        ATH_MSG_VERBOSE("range still valid for " << m_names.at(prx));
      } else {
        ATH_MSG_DEBUG("calling provider()->udpateAddress(TAD) for " << m_names.at(prx)   );
        if (!prx->updateAddress()) {
          ATH_MSG_ERROR("handle: Could not update address");
          return;
        }
      }
      
      if (msgLvl(MSG::VERBOSE)) {
        IOpaqueAddress *ioa = prx->address();
        // Print out some debug info if this is an IOVAddress (coming 
        // from IOVASCIIDbSvc) 
        IOVAddress *iova  = dynamic_cast<IOVAddress*>(ioa);
        if (iova != nullptr) {
          ATH_MSG_VERBOSE("  range: " << iova->range());
        }
      }
 
    }
 
  }  // end if(inc.type() == m_checkTrigger)
 
  if ( inc.type() == IncidentType::BeginRun) {
    s_firstRun = false;
  }
 
}

holdsProxy() [1/2]

bool IOVSvcTool::holdsProxy ( const CLID & clid, const std::string & key ) const

overridevirtual

Definition at line 1038 of file IOVSvcTool.cxx.

                                                                     {
 
  SG::DataProxy* proxy = p_cndSvc->proxy(clid,key);
 
  if (proxy == nullptr) {
    ATH_MSG_ERROR("holdsProxy: could not retrieve proxy "
                  << fullProxyName(clid,key) << " from store");
    return false;
  }
 
  return ( holdsProxy(proxy) );
 
}

holdsProxy() [2/2]

bool IOVSvcTool::holdsProxy ( SG::DataProxy * proxy ) const

overridevirtual

Definition at line 1029 of file IOVSvcTool.cxx.

                                                 {
 
  return m_proxies.contains( proxy );
 
}

ignoreProxy() [1/2]

virtual void IOVSvcTool::ignoreProxy ( const CLID & clid, const std::string & key )

inlineoverridevirtual

Definition at line 138 of file IOVSvcTool.h.

                                                                     {
    m_ignoredProxyNames.insert( std::make_pair(clid,key) );
  }

ignoreProxy() [2/2]

virtual void IOVSvcTool::ignoreProxy ( SG::DataProxy * proxy )

inlineoverridevirtual

Definition at line 142 of file IOVSvcTool.h.

                                                {
    m_ignoredProxies.insert(proxy);
  }

initialize()

StatusCode IOVSvcTool::initialize ( )

overridevirtual

Definition at line 83 of file IOVSvcTool.cxx.

                       {
 
  SmartIF<IProperty> iovSvcProp{service("IOVSvc")};
  ATH_CHECK( iovSvcProp.isValid() );
 
  ATH_CHECK( setProperty( iovSvcProp->getProperty("preLoadRanges") ) );
  ATH_CHECK( setProperty( iovSvcProp->getProperty("preLoadData") ) );
  ATH_CHECK( setProperty( iovSvcProp->getProperty("partialPreLoadData") ) );
  ATH_CHECK( setProperty( iovSvcProp->getProperty("preLoadExtensibleFolders") ) );
  ATH_CHECK( setProperty( iovSvcProp->getProperty("updateInterval") ) );
  ATH_CHECK( setProperty( iovSvcProp->getProperty("sortKeys") ) );
  ATH_CHECK( setProperty( iovSvcProp->getProperty("forceResetAtBeginRun") ) );
  ATH_CHECK( setProperty( iovSvcProp->getProperty("OutputLevel") ) );
 
  int pri=100;
 
  // Convert to uppercase
  std::string updi = m_updateInterval;
  std::transform(updi.begin(), updi.end(), updi.begin(),
                 [](unsigned char c) { return std::toupper(c); });
 
  if (updi== "JOB") {
    m_checkOnce = true;
    m_checkTrigger = "BeginRun";
    p_incSvc->addListener( this, "BeginRun", pri, true);
    msg() << MSG::INFO;
    msg().setColor(MSG::GREEN);
    msg() << "IOVRanges will be checked only ";
    msg().setColor(MSG::CYAN);
    msg() << "once";
    msg().setColor(MSG::GREEN);
    msg() << " at the start of the job" << endmsg;
  } else if (updi == "RUN") {
    m_checkTrigger = "BeginRun";
    p_incSvc->addListener( this, "BeginRun", pri, true);
    msg() << MSG::INFO;
    msg().setColor(MSG::GREEN);
    msg() << "IOVRanges will be checked at every ";
    msg().setColor(MSG::CYAN);
    msg() << "Run" << endmsg;
  } else if (updi == "EVENT") {
    m_checkTrigger = "BeginEvent";
    p_incSvc->addListener( this, "BeginEvent", pri, true);
    p_incSvc->addListener( this, "BeginRun", pri, true);
    msg() << MSG::INFO;
    msg().setColor(MSG::GREEN);
    msg() << "IOVRanges will be checked at every ";
    msg().setColor(MSG::CYAN);
    msg() << "Event" << endmsg;
  } else {
    ATH_MSG_FATAL("jobOption \"updateInterval\" must be one of "
                  << "\"event\" \"run\" or \"job\"");
    return StatusCode::FAILURE;
  }
 
  if (m_preLoadData) {
    msg() << MSG::INFO;
    msg().setColor(MSG::GREEN);
    msg() << "IOV Data will be preloaded at the same interval" << endmsg;
  }
    
  ATH_MSG_DEBUG("Tool initialized");
 
  return StatusCode::SUCCESS;
}

preLoadData()

StatusCode IOVSvcTool::preLoadData ( )

private

preLoadDataTAD()

StatusCode IOVSvcTool::preLoadDataTAD ( const SG::TransientAddress * tad_in )

overridevirtual

add to a set of TADs that who's data will be preLoaded

Definition at line 607 of file IOVSvcTool.cxx.

                                                             {
 
  if (m_preLoad.contains(tad_in)) {
    ATH_MSG_WARNING("preLoadDataTAD: TransientAddress "
                    << fullProxyName( tad_in )
                    << " alread in preLoad set. Not inserting");
    return StatusCode::SUCCESS;
  }
 
  if (m_partPreLoad.contains(TADkey(*tad_in))) {
    ATH_MSG_WARNING("preLoadDataTAD: TransientAddress "
                    << fullProxyName( tad_in )
                    << " alread in partPreLoad set. Not inserting");
    return StatusCode::SUCCESS;
  }
 
  auto tad = std::make_unique<SG::TransientAddress>(tad_in->clID(),tad_in->name());
  m_partPreLoad.insert( TADkey(*tad) );
  m_preLoad.insert( std::move(tad) );
 
  return StatusCode::SUCCESS;
}

preLoadProxies()

StatusCode IOVSvcTool::preLoadProxies ( const EventContext & ctx )

private

Definition at line 803 of file IOVSvcTool.cxx.

                                                {
 
  ATH_MSG_DEBUG("preLoadProxies()");
 
  StatusCode scr(StatusCode::SUCCESS);
 
  SmartIF<IIOVDbSvc> iovDB{service("IOVDbSvc", false)};
 
  for (SG::DataProxy* dp : m_proxies) {
    Gaudi::Guards::AuditorGuard auditor(m_names[dp], auditorSvc(), "preLoadProxy");
    
    if (msgLvl(MSG::VERBOSE)) {
      msg().setColor(MSG::CYAN);
      msg() << "loading proxy for CLID: " << dp->clID()
            << "  " << m_names[dp] << endmsg;
    }
 
    if (dp->provider() == nullptr) {
      msg() << MSG::FATAL << "No provider found for proxy " << m_names[dp]
            << ".  It is probably  not a conditions object" << std::endl;
      msg() << "Proxy Map: ";
      PrintProxyMap(dp);
      msg() << endmsg;
      scr = StatusCode::FAILURE;
      return (scr);
    }
 
 
    StatusCode sc;
    // preload IOVRanges if jobOption set
    // This gets us to an IAddressProvider (eg IOVDbSvc)
    if (m_preLoadRanges) {
      ATH_MSG_VERBOSE("updating Range");
      if (!dp->updateAddress())
        sc = StatusCode::FAILURE;
    }
 
    if ( ( m_partialPreLoadData && 
           m_partPreLoad.contains(TADkey(*dp)) )
         || m_preLoadData ) {
 
      IIOVDbSvc::KeyInfo kinfo;
      if ( !m_preLoadExtensibleFolders && iovDB &&
           iovDB->getKeyInfo(dp->name(), kinfo) && kinfo.extensible ) {
        ATH_MSG_VERBOSE("not preloading data for extensible folder " << dp->name());
      }
      else {
        ATH_MSG_VERBOSE("preloading data for ("
                        << dp->clID() << "/"
                        << dp->name() << ")");
        if( dp->accessData() != nullptr ) {
           sc = StatusCode::SUCCESS;
        } else {
           sc = StatusCode::FAILURE;
           ATH_MSG_ERROR("preLoading proxies: accessData() failed for " <<
                         dp->clID() << "/" << dp->name() << ")");
        }
      }
    }
 
    if (sc.isFailure()) scr=sc;
 
  }
 
  if (scr.isFailure()) {
    ATH_MSG_ERROR("Problems preLoading proxies");
    return scr;
  }
 
  return scr;
}

preLoadTAD()

StatusCode IOVSvcTool::preLoadTAD ( const SG::TransientAddress * tad_in )

overridevirtual

add to a set of TADs that will be registered at start of first event

Definition at line 578 of file IOVSvcTool.cxx.

                                                         {
 
  // check to see if it's a duplicate in preLoad
  if (m_preLoad.contains( tad_in )) {
    ATH_MSG_WARNING("preLoadTAD: TransientAddress ("
                    << tad_in->clID() << "/" << tad_in->name()
                    << ") alread in preLoad set. Not inserting");
    return StatusCode::SUCCESS;
  }
 
  // check to see if it's a duplicate in partPreLoad
  if (m_partPreLoad.contains( TADkey(*tad_in) )) {
    ATH_MSG_WARNING("preLoadTAD: TransientAddress ("
                    << tad_in->clID() << "/" << tad_in->name()
                    << ") alread in partPreLoad set. Not inserting");
    return StatusCode::SUCCESS;
  }
 
  m_preLoad.insert( std::make_unique<SG::TransientAddress>(tad_in->clID(),tad_in->name()) );
 
  return StatusCode::SUCCESS;
}

PrintProxyMap() [1/2]

void IOVSvcTool::PrintProxyMap ( ) const

private

Definition at line 931 of file IOVSvcTool.cxx.

                               {
  msg() << std::endl;
  msg() << "------------------------------  IOVSvc Proxy Map  "
        << "------------------------------" << std::endl;
 
  for (SG::DataProxy* p : m_proxies) {
    PrintProxyMap(p);
  }
  msg() << "----------------------------------------------------------"
        << "---------------------" << std::endl;
}

PrintProxyMap() [2/2]

void IOVSvcTool::PrintProxyMap ( const SG::DataProxy * dp ) const

private

Definition at line 946 of file IOVSvcTool.cxx.

                                                     {
 
  auto it = m_names.find(dp);
  msg() << "  " << dp << "  " << dp->clID() << "  "
        << (it == m_names.end() ? "???" : it->second) << std::endl;
}

PrintStartSet()

void IOVSvcTool::PrintStartSet ( ) const

private

Definition at line 878 of file IOVSvcTool.cxx.

                                {
  std::string objname;
  
  if (!m_startSet_Clock.empty()) {
    msg() << std::endl << "ClockTime start set: " << std::endl;
    for (const auto ent : m_startSet_Clock) {
      objname = m_names.at( ent->proxy() );
      msg() << "  " << objname << " (" << ent->proxy() << ") "
            << ent->range()->start() << std::endl;
    }
    msg() << std::endl;
  }
 
  if (!m_startSet_RE.empty()) {
    msg() << "Run/Event start set: " << std::endl;
    for (const auto ent : m_startSet_RE) {
      objname = m_names.at( ent->proxy() );
      msg() << "  " << objname << " (" << ent->proxy() << ") "
            << ent->range()->start() << std::endl;
    }
  }
 
}

PrintStopSet()

void IOVSvcTool::PrintStopSet ( ) const

private

Definition at line 905 of file IOVSvcTool.cxx.

                               {
  std::string objname;
  
  if (!m_stopSet_Clock.empty()) {
    msg() << std::endl << "ClockTime stop set: " << std::endl;
    for( const auto ent : m_stopSet_Clock ) {
      objname = m_names.at(ent->proxy());
      msg() << "  " << objname << " (" << ent->proxy() << ") "
            << ent->range()->stop() << std::endl;
    }
    msg() << std::endl;
  }
  
  if (!m_stopSet_RE.empty()) {
    msg() << "Run/Event stop set: " << std::endl;
    for( const auto ent : m_stopSet_RE ) {
      objname = m_names.at(ent->proxy());
      msg() << "  " << objname << " (" << ent->proxy() << ") "
            << ent->range()->stop() << std::endl;
    }
  }
}

regProxy() [1/2]

StatusCode IOVSvcTool::regProxy ( const CLID & clid, const std::string & key )

overridevirtual

Register a DataProxy with the service.

Definition at line 538 of file IOVSvcTool.cxx.

                                                             {
 
  SG::DataProxy* proxy = p_cndSvc->proxy(clid,key);
 
  if (proxy == nullptr) {
    ATH_MSG_ERROR("regProxy could not retrieve proxy "
                  << fullProxyName(clid,key) << " from store");
    return StatusCode::FAILURE;
  }
 
  return ( regProxy(proxy, key) );
 
}

regProxy() [2/2]

StatusCode IOVSvcTool::regProxy ( SG::DataProxy * proxy, const std::string & key )

overridevirtual

Register a DataProxy with the service.

Definition at line 405 of file IOVSvcTool.cxx.

                                                              {
 
 
  if (proxy ==  nullptr) {
    ATH_MSG_ERROR("proxy == 0");
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG("registering proxy " << fullProxyName(proxy) << " at " << proxy);
 
  if (m_proxies.contains(proxy)) {
    ATH_MSG_DEBUG("Proxy for " << fullProxyName(proxy)
                  << " already registered: " << proxy->name());
    return StatusCode::SUCCESS;
  }
 
  std::string tname;
  ATH_CHECK( p_CLIDSvc->getTypeNameOfID(proxy->clID(), tname) );
 
  const std::string fullname = tname + "[" + key + "]";
 
  m_proxies.insert( proxy );
  m_names[ proxy ] = std::move(fullname);
 
  return StatusCode::SUCCESS;
 
}

replaceProxy()

StatusCode IOVSvcTool::replaceProxy ( SG::DataProxy * pOld, SG::DataProxy * pNew )

overridevirtual

replace a registered DataProxy with a new version

Definition at line 490 of file IOVSvcTool.cxx.

                                             {
 
  std::scoped_lock lock(m_handleMutex);
  assert(nullptr != pOld);
  assert(nullptr != pNew);
    
  ATH_MSG_DEBUG("replace proxy " << fullProxyName(pOld)
                << " @" << pOld << " with " << fullProxyName(pNew)
                << " @" << pNew);
 
  //start with the proxy list
  if (0 == m_proxies.erase(pOld))  {
    ATH_MSG_DEBUG("unregProxy: original proxy "
                  << fullProxyName(pOld) << " not found. Will return now ");
    return StatusCode::SUCCESS;
  } 
  m_proxies.insert(pNew);
  //new name (possibly identical to old)
  m_names.erase(pOld);
  std::string tname;
  ATH_CHECK( p_CLIDSvc->getTypeNameOfID(pNew->clID(), tname) );
 
  m_names[pNew]=tname + "[" + pNew->name() + "]";
 
  if (pOld != pNew) {
    const auto itr = m_entries.find(pOld);
    if (itr != m_entries.end()) {
      IOVEntry* ent = itr->second.get();
      removeFromSet (ent, m_startSet_Clock);
      removeFromSet (ent, m_startSet_RE);
      removeFromSet (ent, m_stopSet_Clock);
      removeFromSet (ent, m_stopSet_RE);
 
      setRange_impl (pNew, *ent->range());
      m_entries.erase (itr);
    }
  }
 
  return StatusCode::SUCCESS;
 
}

resetAllProxies()

void IOVSvcTool::resetAllProxies ( )

overridevirtual

Definition at line 1055 of file IOVSvcTool.cxx.

                            {
 
  for (SG::DataProxy* prx : m_proxies) {
    ATH_MSG_VERBOSE("clearing proxy payload for " << m_names[prx]);
    
    p_cndSvc->clearProxyPayload(prx);
  }
 
}

scanStartSet()

void IOVSvcTool::scanStartSet ( IOVEntry::StartSet_t & pSet, const std::string & type, std::set< SG::DataProxy *, SortDPptr > & proxiesToReset, const IOVTime & curTime ) const

private

Definition at line 957 of file IOVSvcTool.cxx.

                                           {
 
  if (pSet.empty())  return;
  
  if (msgLvl(MSG::DEBUG)) {
    msg() << MSG::DEBUG << "--> scan for resets: start set: " << type << std::endl;
  }
 
  auto start_itr( pSet.begin() );
  while ( start_itr != pSet.end() ) {
    
    if ((*start_itr)->range()->start() > curTime) {
      if (msgLvl(MSG::DEBUG)) {
        msg() << "\t" << m_names.at((*start_itr)->proxy()) << ": "
              << (*start_itr)->range()->start()<<"   <- removed" << std::endl;
      }
      proxiesToReset.insert( (*start_itr)->proxy() );
 
      (*start_itr)->setRemovedStart( true );
      pSet.erase(start_itr++);
 
    } else {
      break;
    }
  }
 
  if (msgLvl(MSG::DEBUG)) {
    msg() << endmsg;
  }
 
}

scanStopSet()

void IOVSvcTool::scanStopSet ( IOVEntry::StopSet_t & pSet, const std::string & type, std::set< SG::DataProxy *, SortDPptr > & proxiesToReset, const IOVTime & curTime ) const

private

Definition at line 994 of file IOVSvcTool.cxx.

                                          {
 
  if (pSet.empty())  return;
  if (msgLvl(MSG::DEBUG)) {
    msg() << MSG::DEBUG << "--> scan for resets: stop set: " << type << std::endl;
  }
 
  auto stop_itr(pSet.begin());
  while ( stop_itr != pSet.end() ) {
    
    if ((*stop_itr)->range()->stop() <= curTime) {
      if (msgLvl(MSG::DEBUG)) {
        msg() << "   " << m_names.at((*stop_itr)->proxy()) << ": "
              << (*stop_itr)->range()->stop()<< "  -> removed" << std::endl;
      }
      proxiesToReset.insert( (*stop_itr)->proxy() );
      
      (*stop_itr)->setRemovedStop( true );
      pSet.erase(stop_itr++);
      
    } else {
      break;
    }
  }
  if (msgLvl(MSG::DEBUG)) {
    msg() << endmsg;
  }  
 
}

setRange()

StatusCode IOVSvcTool::setRange ( const CLID & clid, const std::string & key, IOVRange & iovr )

overridevirtual

Definition at line 676 of file IOVSvcTool.cxx.

{
 
  ATH_MSG_DEBUG("setRange()  for clid: " << clid << "  key: " << key
                << "  in IOVrange:" << iovr);
 
  if (!iovr.start().isValid() || !iovr.stop().isValid()) {
    ATH_MSG_ERROR("IOVRange " << iovr << "is not valid. Start OK: "
                  << iovr.start().isValid() << " Stop OK: " << iovr.stop().isValid()
                  << " run/evt/time min/max "
                  << IOVTime::MINRUN << "/" << IOVTime::MAXRUN << " "
                  << IOVTime::MINEVENT << "/" << IOVTime::MAXEVENT << " "
                  << IOVTime::MINTIMESTAMP << "/" << IOVTime::MAXTIMESTAMP << " ");
    return StatusCode::FAILURE;
  }
 
  SG::DataProxy* proxy = p_cndSvc->proxy(clid,key);
 
  if (proxy == nullptr) {
    ATH_MSG_ERROR("setRange: Could not locate proxy for " << fullProxyName(clid,key));
    return StatusCode::FAILURE;
  }
 
  std::scoped_lock lock(m_handleMutex);
  setRange_impl (proxy, iovr);
  return StatusCode::SUCCESS;
}

setRange_impl()

void IOVSvcTool::setRange_impl ( SG::DataProxy * proxy, IOVRange & iovr )

private

Definition at line 632 of file IOVSvcTool.cxx.

{
  if (iovr.start().isTimestamp()) {
    p_startSet = &m_startSet_Clock;
    p_stopSet  = &m_stopSet_Clock;
  } else {
    p_startSet = &m_startSet_RE;
    p_stopSet  = &m_stopSet_RE;
  }
 
  auto range = std::make_unique<IOVRange>(iovr);
 
  const auto itr = m_entries.find(proxy);
  if ( itr != m_entries.end() ) {
 
    const auto& ent = itr->second;
 
    if (*ent->range() == iovr) {
      ATH_MSG_DEBUG("Range has not changed. Returning");
      return;
      // is this true? still in the start and stop sets? FIXME
    }
 
    const auto sitr = ent->getStartITR();
    if ( !ent->removedStart() ) {
      p_startSet->erase( sitr );
    }
 
    const auto pitr = ent->getStopITR();
    if ( !ent->removedStop() ) {
      p_stopSet->erase( pitr );
    }
 
  }
 
  ATH_MSG_DEBUG("adding to start and stop sets");
  auto ent = std::make_unique<IOVEntry>(proxy, std::move(range));
  ent->setStartITR( p_startSet->insert( ent.get() ) );
  ent->setStopITR(  p_stopSet->insert( ent.get() ) );
  m_entries.insert_or_assign(proxy, std::move(ent));
}

setRangeInDB()

StatusCode IOVSvcTool::setRangeInDB ( const CLID & clid, const std::string & key, const IOVRange & range, const std::string & tag )

overridevirtual

Definition at line 767 of file IOVSvcTool.cxx.

                                                                      {
 
 
  if (!range.start().isValid() || !range.stop().isValid()) {
    ATH_MSG_ERROR("IOVRange " << range << "is not valid.");
    return StatusCode::FAILURE;
  }
 
  SG::DataProxy* dp = p_cndSvc->proxy(clid,key);
 
  if (dp == nullptr) {
    ATH_MSG_ERROR("no Proxy found for " << fullProxyName( clid, key ));
    return StatusCode::FAILURE;
  }
 
  std::scoped_lock lock(m_handleMutex);
  if (!m_entries.contains(dp)) {
    ATH_MSG_WARNING(fullProxyName(clid,key) << " not registered with the IOVSvc");
  }
 
  IAddressProvider *iadp = dp->provider();
  IIOVDbSvc *idb = dynamic_cast<IIOVDbSvc*>(iadp);
 
  if (idb != nullptr) {
    return idb->setRange(clid, key, range, tag);
  } else {
    ATH_MSG_ERROR("Provider is not an IIOVDbSvc");
    return StatusCode::FAILURE;
  }
 
}

setStoreName()

virtual void IOVSvcTool::setStoreName ( const std::string & storeName )

inlineoverridevirtual

Definition at line 84 of file IOVSvcTool.h.

                                                         {
    m_storeName = storeName;    
  }

TADkey() [1/2]

TADkey_t IOVSvcTool::TADkey ( const SG::DataProxy & p )

inlineprivate

Definition at line 190 of file IOVSvcTool.h.

  { return TADkey_t (p.clID(), p.name()); }

TADkey() [2/2]

TADkey_t IOVSvcTool::TADkey ( const SG::TransientAddress & t )

inlineprivate

Definition at line 192 of file IOVSvcTool.h.

  { return TADkey_t (t.clID(), t.name()); }

Member Data Documentation

ATLAS_THREAD_SAFE

std::recursive_mutex m_handleMutex IOVSvcTool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 165 of file IOVSvcTool.h.

m_checkOnce

bool IOVSvcTool::m_checkOnce {false}

private

Definition at line 197 of file IOVSvcTool.h.

{false};

m_checkTrigger

std::string IOVSvcTool::m_checkTrigger

private

Definition at line 199 of file IOVSvcTool.h.

m_entries

std::map< const SG::DataProxy*, std::unique_ptr<IOVEntry> > IOVSvcTool::m_entries

private

Definition at line 179 of file IOVSvcTool.h.

m_first

std::atomic<bool> IOVSvcTool::m_first {true}

private

Definition at line 196 of file IOVSvcTool.h.

{true};

m_firstEventOfRun

bool IOVSvcTool::m_firstEventOfRun {false}

private

Definition at line 198 of file IOVSvcTool.h.

{false};

m_forceReset

Gaudi::Property<bool> IOVSvcTool::m_forceReset {this, "forceResetAtBeginRun", false}

private

Definition at line 206 of file IOVSvcTool.h.

{this, "forceResetAtBeginRun", false};

m_ignoredProxies

std::set<SG::DataProxy*> IOVSvcTool::m_ignoredProxies

private

Definition at line 176 of file IOVSvcTool.h.

m_ignoredProxyNames

std::set< std::pair<CLID, std::string> > IOVSvcTool::m_ignoredProxyNames

private

Definition at line 177 of file IOVSvcTool.h.

m_names

std::map< const SG::DataProxy*, std::string> IOVSvcTool::m_names

private

Definition at line 163 of file IOVSvcTool.h.

m_partialPreLoadData

Gaudi::Property<bool> IOVSvcTool::m_partialPreLoadData {this, "partialPreLoadData", true}

private

Definition at line 203 of file IOVSvcTool.h.

{this, "partialPreLoadData", true};

m_partPreLoad

std::set< TADkey_t > IOVSvcTool::m_partPreLoad

private

Definition at line 194 of file IOVSvcTool.h.

m_preLoad

std::set< std::unique_ptr<const SG::TransientAddress>, SortTADptr > IOVSvcTool::m_preLoad

private

Definition at line 187 of file IOVSvcTool.h.

m_preLoadData

Gaudi::Property<bool> IOVSvcTool::m_preLoadData {this, "preLoadData", false}

private

Definition at line 202 of file IOVSvcTool.h.

{this, "preLoadData", false};

m_preLoadExtensibleFolders

Gaudi::Property<bool> IOVSvcTool::m_preLoadExtensibleFolders {this, "preLoadExtensibleFolders", true}

private

Definition at line 204 of file IOVSvcTool.h.

{this, "preLoadExtensibleFolders", true};

m_preLoadRanges

Gaudi::Property<bool> IOVSvcTool::m_preLoadRanges {this, "preLoadRanges", false}

private

Definition at line 201 of file IOVSvcTool.h.

{this, "preLoadRanges", false};

m_proxies

std::set< SG::DataProxy*, SortDPptr > IOVSvcTool::m_proxies

private

Definition at line 174 of file IOVSvcTool.h.

m_sortKeys

Gaudi::Property<bool> IOVSvcTool::m_sortKeys {this, "sortKeys", true}

private

Definition at line 205 of file IOVSvcTool.h.

{this, "sortKeys", true};

m_startSet_Clock

IOVEntry::StartSet_t IOVSvcTool::m_startSet_Clock

private

Definition at line 184 of file IOVSvcTool.h.

m_startSet_RE

IOVEntry::StartSet_t IOVSvcTool::m_startSet_RE

private

Definition at line 184 of file IOVSvcTool.h.

m_stopSet_Clock

IOVEntry::StopSet_t IOVSvcTool::m_stopSet_Clock

private

Definition at line 185 of file IOVSvcTool.h.

m_stopSet_RE

IOVEntry::StopSet_t IOVSvcTool::m_stopSet_RE

private

Definition at line 185 of file IOVSvcTool.h.

m_storeName

std::string IOVSvcTool::m_storeName

private

Definition at line 155 of file IOVSvcTool.h.

m_updateInterval

Gaudi::Property<std::string> IOVSvcTool::m_updateInterval {this, "updateInterval", "Event"}

private

Definition at line 207 of file IOVSvcTool.h.

{this, "updateInterval", "Event"};

p_CLIDSvc

ServiceHandle<IClassIDSvc> IOVSvcTool::p_CLIDSvc

private

Definition at line 160 of file IOVSvcTool.h.

p_cndSvc

ServiceHandle<StoreGateSvc> IOVSvcTool::p_cndSvc

private

Definition at line 157 of file IOVSvcTool.h.

p_incSvc

ServiceHandle<IIncidentSvc> IOVSvcTool::p_incSvc

private

Definition at line 158 of file IOVSvcTool.h.

p_PPSvc

ServiceHandle<IProxyProviderSvc> IOVSvcTool::p_PPSvc

private

Definition at line 159 of file IOVSvcTool.h.

p_startSet

IOVEntry::StartSet_t* IOVSvcTool::p_startSet {nullptr}

private

Definition at line 181 of file IOVSvcTool.h.

{nullptr};

p_stopSet

IOVEntry::StopSet_t* IOVSvcTool::p_stopSet {nullptr}

private

Definition at line 182 of file IOVSvcTool.h.

{nullptr};

p_toolSvc

ServiceHandle<IToolSvc> IOVSvcTool::p_toolSvc

private

Definition at line 161 of file IOVSvcTool.h.

---

The documentation for this class was generated from the following files:

• IOVSvcTool.h
• IOVSvcTool.cxx