ATLAS Offline Software
AddressRemappingSvc.cxx
Go to the documentation of this file.
1 /*
2  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
3 */
4 
10 #include "AddressRemappingSvc.h"
11 
12 #include "GaudiKernel/MsgStream.h"
13 #include "GaudiKernel/GenericAddress.h"
14 #include "GaudiKernel/Algorithm.h"
15 #include "GaudiKernel/IAlgManager.h"
16 #include "GaudiKernel/IClassIDSvc.h"
17 
19 #include "AthenaKernel/IRCUSvc.h"
21 
22 #include "SGTools/DataProxy.h"
28 
29 #include <algorithm>
30 
31 #include "boost/range.hpp"
32 
33 
34 //________________________________________________________________________________
35 AddressRemappingSvc::AddressRemappingSvc(const std::string& name, ISvcLocator* pSvcLocator) :
36  base_class(name, pSvcLocator),
37  m_clidSvc("ClassIDSvc", name),
38  m_RCUSvc("Athena::RCUSvc", name),
39  m_oldTads(),
40  m_newTads()
41 {}
42 
43 //__________________________________________________________________________
45 }
46 //__________________________________________________________________________
48  ATH_MSG_VERBOSE("Initializing " << name());
49 
51  ATH_CHECK( m_clidSvc.retrieve() );
52  ATH_CHECK( m_RCUSvc.retrieve() );
53  //ATH_CHECK( m_algResourcePool.retrieve() );
54 
55  m_oldTads.clear();
56  m_newTads.clear();
57  for (const std::string& overwrite : m_overwriteMaps) {
58  const std::string::size_type p_sep = overwrite.find("->");
59  if (p_sep == std::string::npos) {
60  ATH_MSG_ERROR("Unexpected format in TypeKeyOverwriteMaps: " << overwrite);
61  return(StatusCode::FAILURE);
62  }
63  //const std::pair<std::string, std::string> entry(overwrite.substr(0, p_sep), overwrite.substr(p_sep + 2));
64  const std::pair<std::string, std::string> entry(overwrite.substr(p_sep + 2), overwrite.substr(0, p_sep));
65  ATH_MSG_INFO("TypeKeyOverwriteMaps for: " << entry.second
66  << " -> " << entry.first);
67  const std::string::size_type p_oldSep = entry.first.find('#');
68  if (p_oldSep == std::string::npos) {
69  ATH_MSG_ERROR("Unexpected format in TypeKeyOverwriteMaps: " << overwrite);
70  return(StatusCode::FAILURE);
71  }
72 
73  std::string clidStr = entry.first.substr(0, p_oldSep);
74  std::set<CLID> symClids;
75  for (std::string::size_type p_clidSep = clidStr.rfind(','); p_clidSep != std::string::npos; clidStr.resize(p_clidSep), p_clidSep = clidStr.rfind(',')) {
76  symClids.insert(getClid(clidStr.substr(p_clidSep + 1)));
77  }
78  std::string keyStr = entry.first.substr(p_oldSep + 1);
79  SG::TransientAddress oldTad(getClid(clidStr), keyStr);
80  for (std::string::size_type p_keySep = keyStr.rfind(','); p_keySep != std::string::npos; keyStr.resize(p_keySep), p_keySep = keyStr.rfind(',')) {
81  oldTad.setAlias(keyStr.substr(p_keySep + 1));
82  }
83  for (CLID clid : symClids) {
84  oldTad.setTransientID(clid);
85  }
86 
87  const std::string::size_type p_newSep = entry.second.find('#');
88  if (p_newSep == std::string::npos) {
89  ATH_MSG_ERROR("Unexpected format in TypeKeyOverwriteMaps: " << overwrite);
90  return(StatusCode::FAILURE);
91  }
92  SG::TransientAddress newTad(getClid(entry.second.substr(0, p_newSep)), entry.second.substr(p_newSep + 1));
93  ATH_MSG_INFO("TypeKeyOverwriteMaps for: " << newTad.clID()
94  << "#" << newTad.name()
95  << " -> " << oldTad.clID()
96  << "#" << oldTad.name());
97  m_oldTads.push_back(std::move(oldTad));
98  m_newTads.push_back(std::move(newTad));
99  }
100 
102  ATH_CHECK( initInputRenames() );
103  return(StatusCode::SUCCESS);
104 }
105 //__________________________________________________________________________
114 {
115  if (toadd.empty()) return;
116  // Ok, managed via RCU.
118  Athena::RCUUpdate<InputRenameMap_t> u (inputRenames);
119  auto newmap = std::make_unique<InputRenameMap_t> (*u);
120  for (const auto& p : toadd)
121  newmap->insert (p);
122  u.update (std::move (newmap));
123 }
124 //__________________________________________________________________________
128 StatusCode AddressRemappingSvc::initInputRenames()
129 {
130  // Accumulate renames into this map.
131  InputRenameMap_t newmap;
132 
133  // Parse input properties.
134  for (const std::string& remap : m_typeKeyRenameMaps)
135  {
136  std::string::size_type pos1 = remap.find('#');
137  std::string::size_type pos2 = remap.find("->");
138  if (pos1 == std::string::npos || pos2 == std::string::npos || pos2 < pos1)
139  {
140  ATH_MSG_ERROR ( "Bad InputRemaps string: " << remap );
141  continue;
142  }
143 
144  std::string cname = remap.substr (0, pos1);
145  std::string from = remap.substr (pos1+1, pos2-pos1-1);
146  std::string to = remap.substr (pos2+2, std::string::npos);
147  CLID clid = getClid (cname);
148  if (clid == CLID_NULL) {
149  ATH_MSG_ERROR( "Can't find CLID for InputRemaps string: " << remap );
150  continue;
151  }
152 
153  // We have a request to rename FROM to TO for CLID.
154  // Translate to sgkeys and add to the map.
155  SG::sgkey_t from_key = m_proxyDict->stringToKey (from, clid);
156  SG::sgkey_t to_key = m_proxyDict->stringToKey (to, clid);
157  newmap[from_key] = Athena::InputRenameEntry { to_key, std::move(to) };
158  }
159 
160  // Publish the map.
161  addInputRenames (newmap);
162 
163  if (!m_typeKeyRenameMaps.empty()) {
164  SG::setDataProxyHolderInputRenameMap (m_inputRenames.get());
167  *m_proxyDict);
168  }
169 
170  return StatusCode::SUCCESS;
171 }
172 //__________________________________________________________________________
174 {
175  ATH_CHECK( m_clidSvc.release() );
176  ATH_CHECK( m_proxyDict.release() );
177  ATH_CHECK( m_RCUSvc.release() );
178  ATH_CHECK( m_algResourcePool.release() );
180  return(StatusCode::SUCCESS);
181 }
182 //________________________________________________________________________________
185 {
186  return preLoadAddressesConst (storeID, tads);
187 }
189  IAddressProvider::tadList& tads) const
190 {
191  if (storeID == StoreID::EVENT_STORE) {
192  ATH_CHECK( renameTads (tads) );
193  }
194 
195  const std::vector<SG::TransientAddress>* oldTads = nullptr;
196  const std::vector<SG::TransientAddress>* newTads = nullptr;
197 
198  if (m_skipBadRemappings) {
199  // We need to have the cleaned lists built in loadAddresses.
200  // If that hasn't already been done, return now.
202  return StatusCode::SUCCESS;
203  }
204  oldTads = m_oldTadsCleaned.ptr();
205  newTads = m_newTadsCleaned.ptr();
206  }
207  else {
208  // No cleaning needed.
209  oldTads = &m_oldTads;
210  newTads = &m_newTads;
211  }
212 
213  StatusCode status = m_proxyDict.retrieve();
214  if (!status.isSuccess()) {
215  ATH_MSG_ERROR("Unable to get the IProxyDict");
216  return(status);
217  }
218  for (std::vector<SG::TransientAddress>::const_iterator oldIter = oldTads->begin(),
219  newIter = newTads->begin(), oldIterEnd = oldTads->end();
220  oldIter != oldIterEnd; ++oldIter, ++newIter) {
221  SG::TransientAddress* tadd = new SG::TransientAddress(*oldIter);
222  tads.push_back(tadd);
223  m_proxyDict->stringToKey(oldIter->name(), oldIter->clID());
224  m_proxyDict->stringToKey(newIter->name(), newIter->clID());
225  }
226  return(StatusCode::SUCCESS);
227 }
228 //________________________________________________________________________________
231 {
232  if (storeID == StoreID::EVENT_STORE) {
233  initDeletes();
234  ATH_CHECK( renameTads (tads) );
235  }
236  return loadAddressesConst (tads);
237 }
238 
240 {
241  if(!m_skipBadRemappings) return(StatusCode::SUCCESS);
243  return StatusCode::SUCCESS;
244  }
245 
246  std::vector<SG::TransientAddress> oldTadsCleaned = m_oldTads;
247  std::vector<SG::TransientAddress> newTadsCleaned = m_newTads;
248 
249  //do same as in preLoadAddresses, except check each tad will have a valid proxy to remap to
250  StatusCode status = m_proxyDict.retrieve();
251  if (!status.isSuccess()) {
252  ATH_MSG_ERROR("Unable to get the IProxyDict");
253  return(status);
254  }
255  for (std::vector<SG::TransientAddress>::iterator oldIter = oldTadsCleaned.begin(),
256  newIter = newTadsCleaned.begin(), oldIterEnd = oldTadsCleaned.end();
257  oldIter != oldIterEnd; ++oldIter, ++newIter)
258  {
259  CLID goodCLID = newIter->clID(); //newIter are the things we are remapping to
260  SG::TransientAddress::TransientClidSet clidvec(oldIter->transientID());
261  std::set<CLID> clidToKeep (clidvec.begin(), clidvec.end());
262  //try dataproxy, if it fails, try data proxy of next type
263  SG::DataProxy* dataProxy(m_proxyDict->proxy(goodCLID,newIter->name()/*the name of the address in the input file*/));
264  if(dataProxy==0) {
265  //remove goodCLID from the clidToKeep
266  clidToKeep.erase(goodCLID);
267  //try base types
268  const SG::BaseInfoBase* bi = SG::BaseInfoBase::find (newIter->clID());
269  if (bi) {
270  for (CLID goodCLID : bi->get_bases()) {
271  dataProxy = m_proxyDict->proxy(goodCLID, newIter->name());
272  if(dataProxy) break;
273  clidToKeep.erase(goodCLID); //was a bad CLID, so get rid of it
274  }
275  }
276  if(dataProxy) {
277  ATH_MSG_DEBUG("Remapping " << oldIter->clID() << "#" << oldIter->name() << " to base-class CLID: " << goodCLID << "#" << newIter->name());
278  //modify newIter to have these restricted clid instead
279  *newIter = SG::TransientAddress(goodCLID, newIter->name());
280  }
281  }
282  if(dataProxy==0) {
283  ATH_MSG_INFO("Skipping remapping of " << oldIter->clID() << "#" << oldIter->name() << " because no suitable remapping found");
284  continue;
285  }
286  SG::TransientAddress* tadd = new SG::TransientAddress(goodCLID,oldIter->name(),oldIter->address());
287  tadd->setAlias(oldIter->alias());//match the aliases
288  //also match the transientIDs, but only for the ok CLID
289  for(auto tIter = clidToKeep.begin(); tIter != clidToKeep.end(); ++tIter) {
290  if(goodCLID == *tIter) continue; //already added in constructor
291  tadd->setTransientID(goodCLID);
292  }
293  //replace oldIter tad with this new tadd if we have changed the primary CLID
294  if(oldIter->clID()!=tadd->clID()) {
295  *oldIter = *tadd; //relies on assignment operator
296  }
297  tads.push_back(tadd);
298  m_proxyDict->stringToKey(oldIter->name(), oldIter->clID());
299  m_proxyDict->stringToKey(newIter->name(), newIter->clID());
300  }
301 
302 
303  //only do this once, not every event .. FIXME: Should I be rechecking every new file? For now, we assume will not chain together different sample types
304  m_oldTadsCleaned.set (std::move (oldTadsCleaned));
305  m_newTadsCleaned.set (std::move (newTadsCleaned));
306 
307  return StatusCode::SUCCESS;
308 
309 }
310 //________________________________________________________________________________
313  const EventContext& ctx)
314 {
315  return updateAddressConst (storeID, tad, ctx);
316 }
319  const EventContext& /*ctx*/) const
320 {
321  const std::vector<SG::TransientAddress>* oldTads = nullptr;
322  const std::vector<SG::TransientAddress>* newTads = nullptr;
323 
325  oldTads = m_oldTadsCleaned.ptr();
326  newTads = m_newTadsCleaned.ptr();
327  }
328  else {
329  // No cleaning needed.
330  oldTads = &m_oldTads;
331  newTads = &m_newTads;
332  }
333 
334  for (std::vector<SG::TransientAddress>::const_iterator oldIter = oldTads->begin(),
335  newIter = newTads->begin(), oldIterEnd = oldTads->end();
336  oldIter != oldIterEnd; ++oldIter, ++newIter) {
337  if (oldIter->transientID(tad->clID()) &&
338  (oldIter->name() == tad->name() || oldIter->hasAlias (tad->name())))
339  {
340  ATH_MSG_DEBUG("Overwrite for: " << tad->clID() << "#" << tad->name() << " -> " << newIter->clID() << "#" << newIter->name());
341  SG::DataProxy* dataProxy(m_proxyDict->proxy(newIter->clID(), newIter->name()));
342  if (dataProxy == 0) {
343  ATH_MSG_WARNING("Cannot get proxy for: " << newIter->clID() << "#" << newIter->name());
344  return(StatusCode::FAILURE);
345  }
346  GenericAddress* newGadd = 0;
347  if (dataProxy->isValidAddress()) newGadd = dynamic_cast<GenericAddress*>(dataProxy->address());
348  if (newGadd == 0) {
349  ATH_MSG_WARNING("Cannot get GenericAddress for: " << newIter->clID() << "#" << newIter->name());
350  return(StatusCode::FAILURE);
351  }
352  GenericAddress* oldGadd = new GenericAddress(newGadd->svcType(), tad->clID(), *newGadd->par(), tad->name(), *newGadd->ipar());
353  tad->setAddress(oldGadd);
354  return(StatusCode::SUCCESS);
355  }
356  }
357  return(StatusCode::FAILURE);
358 }
359 //_______________________________________________________________________________
365 {
366  // Fetch the current rename map using RCU.
368 
369  // We can exit early if there's nothing to do.
370  // FIXME: m_deletes will almost never be empty, but many times it will have
371  // no overlap with the input file. Should try to speed up by
372  // noticing/caching that somehow.
373  {
374  std::scoped_lock lock (m_deletesMutex);
375  if (r->empty() && m_deletes.empty()) return StatusCode::SUCCESS;
376  }
377 
378  // We may discover additional remappings due to autosymlinking.
379  // Accumulate them here.
380  InputRenameMap_t newmap;
381 
382  // Loop over all TADs.
385  while (pos != end) {
386  SG::TransientAddress*& tad = *pos;
387 
388  // Has the object described by this TAD been renamed?
389  // FIXME: Handle renaming aliases.
390  CLID tad_clid = tad->clID();
391  SG::sgkey_t sgkey = m_proxyDict->stringToKey (tad->name(), tad_clid);
392  auto it = r->find (sgkey);
393  if (it != r->end()) {
394  const std::string& name_renamed = it->second.m_key;
395 
396  // We're doing a renaming. Make a new TAD with the new name.
397  auto tad_new = std::make_unique<SG::TransientAddress>
398  (tad_clid, name_renamed,
399  tad->address(), tad->clearAddress());
400  for (CLID clid : tad->transientID()) {
401  if (clid == tad_clid) continue;
402  tad_new->setTransientID (clid);
403  SG::sgkey_t from_key = m_proxyDict->stringToKey (tad->name(), clid);
404  if (r->find(from_key) == r->end()) {
405  SG::sgkey_t to_key = m_proxyDict->stringToKey (name_renamed, clid);
406  newmap[from_key] = Athena::InputRenameEntry { to_key, name_renamed };
407  }
408  }
409 
410  size_t namelen = tad->name().size();
411  for (const std::string& a : tad->alias()) {
412  std::string a_renamed = a;
413 
414  SG::sgkey_t from_key = m_proxyDict->stringToKey (a_renamed, tad_clid);
415  auto it_a = r->find (from_key);
416  if (it_a != r->end()) {
417  a_renamed = it_a->second.m_key;
418  }
419 
420  if (strncmp (a_renamed.c_str(), tad->name().c_str(), namelen) == 0 &&
421  a_renamed[namelen] == '.')
422  {
423  a_renamed = name_renamed + a_renamed.substr (namelen, std::string::npos);
424  }
425 
426  tad_new->setAlias (a_renamed);
427  }
428  tad_new->setProvider (tad->provider(), tad->storeID());
429 
430  // Replace the old TAD in the list with the new one.
431  delete tad;
432  tad = tad_new.release();
433 
434  ++pos;
435  }
436 
437  else if (isDeleted (*tad)) {
438  // Rename the existing TAD to end in _DELETED.
439  // Drop symlinks in the process.
440  auto tad_new = std::make_unique<SG::TransientAddress>
441  (tad->clID(), tad->name() + "_DELETED",
442  tad->address(), tad->clearAddress());
443  tad_new->setProvider (tad->provider(), tad->storeID());
444  // Preserve alias information, also renaming them to end in _DELETED.
445  for (const std::string& a : tad->alias()) {
446  tad_new->setAlias (a + "_DELETED");
447  }
448  // Replace the old TAD in the list with the new one.
449  delete tad;
450  tad = tad_new.release();
451 
452  ++pos;
453  }
454 
455  else {
456  // Check for renaming of an alias; eg., for renaming a dynamic vbl.
458  for (const std::string& a : aset) {
459  SG::sgkey_t from_key = m_proxyDict->stringToKey (a, tad_clid);
460  auto it_a = r->find (from_key);
461  if (it_a != r->end()) {
462  const std::string& s = it_a->second.m_key;
463  tad->removeAlias (a);
464  tad->setAlias (s);
465  }
466  }
467 
468  ++pos;
469  }
470  }
471 
472  // Publish additional remappings.
473  addInputRenames (newmap);
474 
475  return StatusCode::SUCCESS;
476 }
477 
478 
479 //________________________________________________________________________________
480 CLID AddressRemappingSvc::getClid(const std::string& type) const {
481  CLID clid(atoi(type.c_str())); // Is type a CLID?
482  if (clid == 0) { // or not
483  if (!m_clidSvc->getIDOfTypeName(type, clid).isSuccess()) {
484  return(0);
485  }
486  }
487  return(clid);
488 }
489 //______________________________________________________________________________
492 {
493  if (m_typeKeyRenameMaps.empty())
494  return nullptr;
495  return m_inputRenames.get();
496 }
497 //______________________________________________________________________________
499 {
500  if (m_haveDeletes) return;
501 
502  std::list<IAlgorithm*> algs = m_algResourcePool->getFlatAlgList();
503 
504  std::scoped_lock lock (m_deletesMutex);
505  if (m_haveDeletes) return;
506  m_haveDeletes = true;
507 
508  for (IAlgorithm* ialg : algs) {
509  if (Gaudi::Algorithm* alg = dynamic_cast<Gaudi::Algorithm*> (ialg)) {
510  // Need to ignore SGInputLoader; it'll have output deps
511  // on everything being read.
512  if (alg->name() == "SGInputLoader") continue;
513 
514  // Also ignore ViewDataVerifier algs, since they have no real output
515  if (alg->type() == "AthViews::ViewDataVerifier" ) continue;
516 
517  for (const DataObjID& dobj : alg->outputDataObjs()) {
518  static const std::string pref = "StoreGateSvc+";
519  if (dobj.key().rfind(pref, 0) != std::string::npos) {
520  std::string key = dobj.key().substr (pref.size());
521  m_deletes.emplace (key, dobj.clid());
522 
523  // If this looks like an xAOD type, then also make an entry
524  // for an aux store. Don't want to try to rely on BaseInfo here,
525  // as we may not have loaded the proper libraries yet.
526  // Second line of the test is to handle the tests in DataModelTest.
527  if (dobj.fullKey().find ("xAOD") != std::string::npos ||
528  dobj.fullKey().find ("cinfo") != std::string::npos)
529  {
530  m_deletes.emplace (key + "Aux.",
532  }
533  }
534  }
535  } else {
536  ATH_MSG_WARNING(ialg->name() << " doesn't seem to be an Algorithm" );
537  }
538 
539  }
540 }
541 //______________________________________________________________________________
543 {
544  std::string key = tad.name();
545  std::scoped_lock lock (m_deletesMutex);
546  for (const auto& p : boost::make_iterator_range (m_deletes.equal_range (key))) {
547  CLID clid = p.second;
548  if (tad.transientID (clid)) {
549  return true;
550  }
551  }
552  return false;
553 }
554 
555 
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
python.PyAthenaComps.algs
algs
Definition: PyAthenaComps.py:41
beamspotman.r
def r
Definition: beamspotman.py:674
common.sgkey
def sgkey(tool)
Definition: common.py:1027
Athena::RCUObject
Wrapper object controlled by RCU synchonization.
Definition: RCUObject.h:322
AddressRemappingSvc::isDeleted
bool isDeleted(const SG::TransientAddress &tad) const
Definition: AddressRemappingSvc.cxx:542
AddressRemappingSvc::~AddressRemappingSvc
virtual ~AddressRemappingSvc()
Destructor.
Definition: AddressRemappingSvc.cxx:44
python.tests.PyTestsLib.finalize
def finalize(self)
_info( "content of StoreGate..." ) self.sg.dump()
Definition: PyTestsLib.py:50
AddressRemappingSvc::m_skipBadRemappings
Gaudi::Property< bool > m_skipBadRemappings
Definition: AddressRemappingSvc.h:116
CxxUtils::CachedValue::ptr
const T * ptr() const
Return a pointer to the cached value.
Athena::RCUUpdate
Helper to update data in a RCUObject.
Definition: RCUObject.h:138
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
SG::TransientAddress::storeID
StoreID::type storeID() const
Definition: TransientAddress.h:334
SG::AuxTypeRegistry::instance
static AuxTypeRegistry & instance()
Return the singleton registry instance.
Definition: AuxTypeRegistry.cxx:639
AddressRemappingSvc::addInputRenames
void addInputRenames(const InputRenameMap_t &toadd) const
Merge in additional input rename mappings.
Definition: AddressRemappingSvc.cxx:113
CxxUtils::CachedValue::isValid
bool isValid() const
Test to see if the value is valid.
initialize
void initialize()
Definition: run_EoverP.cxx:894
AddressRemappingSvc::m_inputRenames
std::unique_ptr< InputRenameRCU_t > m_inputRenames
Definition: AddressRemappingSvc.h:114
SG::TransientAddress::setAlias
void setAlias(const std::string &key)
set alias'
Definition: TransientAddress.h:260
skel.it
it
Definition: skel.GENtoEVGEN.py:407
AddressRemappingSvc::m_oldTads
std::vector< SG::TransientAddress > m_oldTads
Definition: AddressRemappingSvc.h:90
AddressRemappingSvc::m_oldTadsCleaned
CxxUtils::CachedValue< std::vector< SG::TransientAddress > > m_oldTadsCleaned
Definition: AddressRemappingSvc.h:97
SG::TransientAddress
Definition: TransientAddress.h:32
SG::TransientAddress::TransientClidSet
std::vector< CLID > TransientClidSet
Strictly a set, but there shouldn't be more than a handful of entries, so store it as a sorted vector...
Definition: TransientAddress.h:38
python.RatesEmulationExample.lock
lock
Definition: RatesEmulationExample.py:148
SG::TransientAddress::removeAlias
bool removeAlias(const std::string &key)
remove alias from proxy
Definition: TransientAddress.h:283
AddressRemappingSvc::m_haveDeletes
std::atomic< bool > m_haveDeletes
Definition: AddressRemappingSvc.h:121
ATH_MSG_VERBOSE
#define ATH_MSG_VERBOSE(x)
Definition: AthMsgStreamMacros.h:28
SG::BaseInfoBase::get_bases
const std::vector< CLID > & get_bases() const
Return the class IDs of all known bases of T (that have class IDs).
Definition: BaseInfo.cxx:304
AddressRemappingSvc::AddressRemappingSvc
AddressRemappingSvc(const std::string &name, ISvcLocator *pSvcLocator)
Standard Service Constructor.
Definition: AddressRemappingSvc.cxx:35
Trk::u
@ u
Enums for curvilinear frames.
Definition: ParamDefs.h:77
python.CaloAddPedShiftConfig.type
type
Definition: CaloAddPedShiftConfig.py:42
IRCUSvc.h
read-copy-update (RCU) style synchronization for Athena.
AddressRemappingSvc::initDeletes
void initDeletes()
Definition: AddressRemappingSvc.cxx:498
mergePhysValFiles.end
end
Definition: DataQuality/DataQualityUtils/scripts/mergePhysValFiles.py:92
AddressRemappingSvc::loadAddresses
virtual StatusCode loadAddresses(StoreID::type storeID, IAddressProvider::tadList &tads) override
Implementation of the loadAddresses function without any functionality.
Definition: AddressRemappingSvc.cxx:229
AddressRemappingSvc::m_clidSvc
ServiceHandle< IClassIDSvc > m_clidSvc
Definition: AddressRemappingSvc.h:81
AddressRemappingSvc::m_overwriteMaps
StringArrayProperty m_overwriteMaps
TypeKeyOverwriteMaps, map for type::key overwrites.
Definition: AddressRemappingSvc.h:89
SG::TransientAddress::name
const std::string & name() const
Get the primary (hashed) SG key.
Definition: TransientAddress.h:217
AddressRemappingSvc::m_newTadsCleaned
CxxUtils::CachedValue< std::vector< SG::TransientAddress > > m_newTadsCleaned
Definition: AddressRemappingSvc.h:98
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:209
Athena::InputRenameEntry
Type of the input rename map: sgkey_t -> sgkey_t.
Definition: InputRenameMap.h:28
SG::DataProxy::address
virtual IOpaqueAddress * address() const override final
Retrieve IOpaqueAddress.
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
SG::TransientAddress::alias
const TransientAliasSet & alias() const
set the clearAddress flag: IOA will not be deleted in proxy
Definition: TransientAddress.h:301
AddressRemappingSvc::renameTads
StatusCode renameTads(IAddressProvider::tadList &tads) const
Scan TAD list and carry out any requested renamings.
Definition: AddressRemappingSvc.cxx:364
DataProxyHolderInputRename.h
SG::TransientAddress::provider
IAddressProvider * provider()
Definition: TransientAddress.h:329
AddressRemappingSvc::m_algResourcePool
ServiceHandle< IAlgResourcePool > m_algResourcePool
Definition: AddressRemappingSvc.h:85
ClassID_traits.h
a traits class that associates a CLID to a type T It also detects whether T inherits from Gaudi DataO...
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
Athena::RCURead
Helper to read data from a RCUObject.
Definition: RCUObject.h:136
SG::TransientAddress::clID
CLID clID() const
Retrieve string key:
Definition: TransientAddress.h:210
ClassID_traits
Default, invalid implementation of ClassID_traits.
Definition: Control/AthenaKernel/AthenaKernel/ClassID_traits.h:37
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
AddressRemappingSvc.h
This file contains the class definition for the AddressRemappingSvc class.
AddressRemappingSvc::InputRenameMap_t
Athena::InputRenameMap_t InputRenameMap_t
Map of sgkey->sgkey for input renames.
Definition: AddressRemappingSvc.h:112
CLID
uint32_t CLID
The Class ID type.
Definition: Event/xAOD/xAODCore/xAODCore/ClassID_traits.h:47
GetAllXsec.entry
list entry
Definition: GetAllXsec.py:132
AddressRemappingSvc::m_RCUSvc
ServiceHandle< Athena::IRCUSvc > m_RCUSvc
Definition: AddressRemappingSvc.h:84
AddressRemappingSvc::m_deletes
std::unordered_multimap< std::string, CLID > m_deletes
Definition: AddressRemappingSvc.h:122
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:240
SG::BaseInfoBase::find
static const BaseInfoBase * find(CLID clid)
Find the BaseInfoBase instance for clid.
Definition: BaseInfo.cxx:570
SG::AuxTypeRegistry::setInputRenameMap
void setInputRenameMap(const Athena::InputRenameMap_t *map, const IStringPool &pool)
Declare input renaming requests.
Definition: AuxTypeRegistry.cxx:1237
RegSelToolConfig.alg
alg
Definition: RegSelToolConfig.py:332
SG::TransientAddress::setTransientID
void setTransientID(CLID id)
get transient CLID's
Definition: TransientAddress.cxx:164
SG::sgkey_t
uint32_t sgkey_t
Type used for hashed StoreGate key+CLID pairs.
Definition: CxxUtils/CxxUtils/sgkey_t.h:32
CxxUtils::CachedValue::set
void set(const T &val) const
Set the value, assuming it is currently invalid.
SG::TransientAddress::setAddress
void setAddress(IOpaqueAddress *pAddress)
Retrieve primary clid.
Definition: TransientAddress.cxx:194
python.LumiBlobConversion.pos
pos
Definition: LumiBlobConversion.py:16
CxxUtils::to
CONT to(RANGE &&r)
Definition: ranges.h:39
AddressRemappingSvc::preLoadAddressesConst
StatusCode preLoadAddressesConst(StoreID::type storeID, IAddressProvider::tadList &tads) const
Definition: AddressRemappingSvc.cxx:188
AddressRemappingSvc::m_proxyDict
ServiceHandle< IProxyDict > m_proxyDict
Definition: AddressRemappingSvc.h:82
a
TList * a
Definition: liststreamerinfos.cxx:10
remap
std::map< std::string, std::string > remap
list of directories to be explicitly remapped
Definition: hcg.cxx:92
StoreID::type
type
Definition: StoreID.h:24
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
AddressRemappingSvc::preLoadAddresses
virtual StatusCode preLoadAddresses(StoreID::type storeID, IAddressProvider::tadList &tads) override
Get all addresses from provider.
Definition: AddressRemappingSvc.cxx:183
TransientAddress.h
SG::BaseInfoBase
The non-template portion of the BaseInfo implementation.
Definition: Control/AthenaKernel/AthenaKernel/BaseInfo.h:451
AddressRemappingSvc::updateAddressConst
StatusCode updateAddressConst(StoreID::type, SG::TransientAddress *pTad, const EventContext &ctx) const
Definition: AddressRemappingSvc.cxx:317
AuxTypeRegistry.h
Handle mappings between names and auxid_t.
AddressRemappingSvc::m_typeKeyRenameMaps
Gaudi::Property< std::vector< std::string > > m_typeKeyRenameMaps
Property: list of requested input renames.
Definition: AddressRemappingSvc.h:101
IAuxStore.h
Interface for non-const operations on an auxiliary store.
AddressRemappingSvc::inputRenameMap
virtual const IInputRename::InputRenameRCU_t * inputRenameMap() const override
Retrieve a pointer to the input rename map.
Definition: AddressRemappingSvc.cxx:491
python.SystemOfUnits.s
float s
Definition: SystemOfUnits.py:147
IAddressProvider::tadList
std::list< SG::TransientAddress * > tadList
Definition: IAddressProvider.h:32
AddressRemappingSvc::updateAddress
virtual StatusCode updateAddress(StoreID::type, SG::TransientAddress *pTad, const EventContext &ctx) override
Update a transient address.
Definition: AddressRemappingSvc.cxx:311
AddressRemappingSvc::loadAddressesConst
StatusCode loadAddressesConst(IAddressProvider::tadList &tads) const
Definition: AddressRemappingSvc.cxx:239
SG::DataProxy::isValidAddress
bool isValidAddress() const
is the address valid?
Definition: DataProxy.cxx:575
SG::TransientAddress::clearAddress
void clearAddress(const bool &flag)
Return the clearAddress flag.
Definition: TransientAddress.h:308
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
merge.status
status
Definition: merge.py:16
ATLAS_THREAD_SAFE
#define ATLAS_THREAD_SAFE
Definition: checker_macros.h:211
StoreID::EVENT_STORE
@ EVENT_STORE
Definition: StoreID.h:26
SG::TransientAddress::TransientAliasSet
std::vector< std::string > TransientAliasSet
Definition: TransientAddress.h:40
IConstAuxStore.h
Interface for const operations on an auxiliary store.
checker_macros.h
Define macros for attributes used to control the static checker.
SG::DataProxy
Definition: DataProxy.h:45
SG::TransientAddress::transientID
bool transientID(CLID id) const
set transient CLID's
Definition: TransientAddress.h:245
AddressRemappingSvc::m_deletesMutex
std::mutex m_deletesMutex
Definition: AddressRemappingSvc.h:120
AddressRemappingSvc::finalize
virtual StatusCode finalize() override
Required of all Gaudi services:
Definition: AddressRemappingSvc.cxx:173
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
DataProxy.h
AddressRemappingSvc::m_newTads
std::vector< SG::TransientAddress > m_newTads
Definition: AddressRemappingSvc.h:91
AddressRemappingSvc::getClid
CLID getClid(const std::string &type) const
Definition: AddressRemappingSvc.cxx:480