AthenaPoolCnvSvc Class Reference

This class provides the interface between Athena and PoolSvc. More...

#include <AthenaPoolCnvSvc.h>

Inheritance diagram for AthenaPoolCnvSvc:

Collaboration diagram for AthenaPoolCnvSvc:

Public Member Functions
virtual StatusCode	initialize () override
	Required of all Gaudi Services.
virtual StatusCode	io_reinit () override
virtual StatusCode	finalize () override
	Required of all Gaudi Services.
virtual StatusCode	io_finalize () override
virtual StatusCode	stop () override
virtual StatusCode	createObj (IOpaqueAddress *pAddress, DataObject *&refpObject) override
	Implementation of IConversionSvc: Create the transient representation of an object from persistent state.
virtual StatusCode	createRep (DataObject *pObject, IOpaqueAddress *&refpAddress) override
	Implementation of IConversionSvc: Convert the transient object to the requested representation.
virtual StatusCode	fillRepRefs (IOpaqueAddress *pAddress, DataObject *pObject) override
	Implementation of IConversionSvc: Resolve the references of the converted object.
virtual StatusCode	connectOutput (const std::string &outputConnectionSpec, const std::string &openMode) override
	Implementation of IConversionSvc: Connect to the output connection specification with open mode.
virtual StatusCode	connectOutput (const std::string &outputConnectionSpec) override
	Implementation of IConversionSvc: Connect to the output connection specification with open mode.
virtual StatusCode	commitOutput (const std::string &outputConnectionSpec, bool doCommit) override
	Implementation of IConversionSvc: Commit pending output.
virtual StatusCode	disconnectOutput (const std::string &outputConnectionSpec) override
	Disconnect to the output connection.
virtual IPoolSvc *	getPoolSvc () override
virtual Token *	registerForWrite (Placement *placement, const void *obj, const RootType &classDesc) override
virtual void	setObjPtr (void *&obj, const Token *token) override
virtual bool	useDetailChronoStat () const override
StatusCode	createAddress (long svcType, const CLID &clid, const std::string *par, const unsigned long *ip, IOpaqueAddress *&refpAddress) override
	Create a Generic address using explicit arguments to identify a single object.
virtual StatusCode	createAddress (long svcType, const CLID &clid, const std::string &refAddress, IOpaqueAddress *&refpAddress) override
	Create address from string form.
virtual StatusCode	convertAddress (const IOpaqueAddress *pAddress, std::string &refAddress) override
	Convert address to string form.
virtual StatusCode	registerCleanUp (IAthenaPoolCleanUp *cnv) override
	Implement registerCleanUp to register a IAthenaPoolCleanUp to be called during cleanUp.
virtual StatusCode	cleanUp (const std::string &connection) override
	Implement cleanUp to call all registered IAthenaPoolCleanUp cleanUp() function.
virtual StatusCode	setInputAttributes (const std::string &fileName) override
	Set the input file attributes, if any are requested from jobOpts.
virtual void	handle (const Incident &incident) override
	Implementation of IIncidentListener: Handle for EndEvent incidence.
void	flushDataHeaderForms (const std::string &streamName="*")
	Tell DataHeaderCnv to write out all DataHeaderForms for a given streamName (default is all).
	AthenaPoolCnvSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Service Constructor.
virtual	~AthenaPoolCnvSvc ()=default
	Destructor.

Protected Member Functions
unsigned	outputContextId (const std::string &outputConnection)

Protected Attributes
PMonUtils::BasicStopWatchResultMap_t	m_chronoMap {}
	Map that holds chrono information.
Gaudi::Property< bool >	m_persSvcPerOutput {this,"PersSvcPerOutput",true}
	PersSvcPerOutput, boolean property to use multiple persistency services, one per output stream.
Gaudi::Property< std::string >	m_persSvcPerInputType {this,"PersSvcPerInputType",""}
	PersSvcPerInputType, string property, tree name to use multiple persistency services, one per input type.
std::mutex	m_mutex
std::set< unsigned int >	m_processedContextIds
	Track context IDs for which extractPoolAttributes has been called.
Gaudi::Property< bool >	m_oneDataHeaderForm { this, "OneDataHeaderForm", false }
	If true, use only one DataHeaderForm per Stream.
Gaudi::Property< int >	m_DHFormCacheSize { this, "maxDHFormCacheSize", 100 }
	Property for DataHeaderCnv input DHForm cache size.
Gaudi::Property< bool >	m_DHFilterAliases { this, "doFilterDHAliases", true }
	Flag to control SG alias filtering when writing out DataHeader (see DataHeaderCnv_p6).

Private Member Functions
void	extractPoolAttributes (const Gaudi::Property< std::vector< std::string > > &property, std::vector< std::vector< std::string > > *contAttr, std::vector< std::vector< std::string > > *dbAttr, std::vector< std::vector< std::string > > *domAttr=0) const
	Extract POOL ItechnologySpecificAttributes for Domain, Database and Container from property.
StatusCode	processPoolAttributes (std::vector< std::vector< std::string > > &attr, const std::string &fileName, unsigned long contextId, bool doGet=true, bool doSet=true, bool doClear=true) const
	Set/get technology dependent POOL attributes.

Private Attributes
std::string	m_lastInputFileName
	decoded storage tech requested in "StorageTechnology" property
ServiceHandle< IPoolSvc >	m_poolSvc {this,"PoolSvc","PoolSvc"}
ServiceHandle< IClassIDSvc >	m_clidSvc {this,"ClassIDSvc","ClassIDSvc"}
Gaudi::Property< bool >	m_useDetailChronoStat {this,"UseDetailChronoStat",false}
	UseDetailChronoStat, enable detailed output for time and size statistics for AthenaPOOL: default = false.
Gaudi::Property< std::string >	m_containerNamingSchemeProp {this, "PoolContainerNamingScheme", "Historical"}
	POOL container naming scheme selection.
Gaudi::Property< std::vector< std::string > >	m_poolAttr {this,"PoolAttributes",{},"Pool Attributes","OrderedSet<std::string>"}
	Output PoolAttributes, vector with names and values of technology specific attributes for POOL.
std::vector< std::vector< std::string > >	m_domainAttr
std::vector< std::vector< std::string > >	m_databaseAttr
std::vector< std::vector< std::string > >	m_containerAttr
Gaudi::Property< std::vector< std::string > >	m_inputPoolAttr {this,"InputPoolAttributes",{}}
	Input PoolAttributes, vector with names and values of technology specific attributes for POOL.
std::vector< std::vector< std::string > >	m_inputAttr
Gaudi::Property< std::vector< std::string > >	m_inputPoolAttrPerEvent {this,"PrintInputAttrPerEvt",{}}
	Print input PoolAttributes per event, vector with names of technology specific attributes for POOL to be printed each event.
std::vector< std::vector< std::string > >	m_inputAttrPerEvent

Friends
class	SvcFactory< AthenaPoolCnvSvc >

Detailed Description

This class provides the interface between Athena and PoolSvc.

Definition at line 40 of file AthenaPoolCnvSvc.h.

Constructor & Destructor Documentation

AthenaPoolCnvSvc()

AthenaPoolCnvSvc::AthenaPoolCnvSvc	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Standard Service Constructor.

Definition at line 463 of file AthenaPoolCnvSvc.cxx.

                                                                                  :
    base_class(name, pSvcLocator, pool::POOL_StorageType.type()) {
}

~AthenaPoolCnvSvc()

virtual AthenaPoolCnvSvc::~AthenaPoolCnvSvc ( )

virtualdefault

Destructor.

Member Function Documentation

cleanUp()

StatusCode AthenaPoolCnvSvc::cleanUp ( const std::string & connection )

overridevirtual

Implement cleanUp to call all registered IAthenaPoolCleanUp cleanUp() function.

Definition at line 412 of file AthenaPoolCnvSvc.cxx.

                                                                {
   bool retError = false;
   std::size_t cpos = connection.find(':');
   std::size_t bpos = connection.find('[');
   if (cpos == std::string::npos) {
      cpos = 0;
   } else {
      cpos++;
   }
   if (bpos != std::string::npos) bpos = bpos - cpos;
   const std::string conn = connection.substr(cpos, bpos);
   ATH_MSG_VERBOSE("Cleanup for Connection='"<< conn <<"'");
   for (auto converter : m_cnvs) {
      if (!converter->cleanUp(conn).isSuccess()) {
         ATH_MSG_WARNING("AthenaPoolConverter cleanUp failed.");
         retError = true;
      }
   }
   return(retError ? StatusCode::FAILURE : StatusCode::SUCCESS);
}

commitOutput()

StatusCode AthenaPoolCnvSvc::commitOutput ( const std::string & outputConnectionSpec, bool doCommit )

overridevirtual

Implementation of IConversionSvc: Commit pending output.

Parameters

doCommit

[IN] boolean to force full commit

Definition at line 263 of file AthenaPoolCnvSvc.cxx.

                                                                                              {
   // This is called after all DataObjects are converted.
   std::string outputConnection = outputConnectionSpec.substr(0, outputConnectionSpec.find('['));
   // StopWatch listens from here until the end of this current scope
   PMonUtils::BasicStopWatch stopWatch("commitOutput", m_chronoMap);
   std::unique_lock<std::mutex> lock(m_mutex);
   unsigned int contextId = outputContextId(outputConnection);
   if (!processPoolAttributes(m_domainAttr, outputConnection, contextId).isSuccess()) {
      ATH_MSG_DEBUG("commitOutput failed process POOL domain attributes.");
   }
   if (!processPoolAttributes(m_databaseAttr, outputConnection, contextId).isSuccess()) {
      ATH_MSG_DEBUG("commitOutput failed process POOL database attributes.");
   }
   if (!processPoolAttributes(m_containerAttr, outputConnection, contextId).isSuccess()) {
      ATH_MSG_DEBUG("commitOutput failed process POOL container attributes.");
   }
 
   // lock.unlock();  //MN: first need to make commitCache slot-specific
   try {
      if (doCommit) {
         if (!m_poolSvc->commit(contextId).isSuccess()) {
            ATH_MSG_ERROR("commitOutput FAILED to commit OutputStream.");
            return(StatusCode::FAILURE);
         }
      } else {
         if (!m_poolSvc->commitAndHold(contextId).isSuccess()) {
            ATH_MSG_ERROR("commitOutput FAILED to commitAndHold OutputStream.");
            return(StatusCode::FAILURE);
         }
      }
   } catch (std::exception& e) {
      ATH_MSG_ERROR("commitOutput - caught exception: " << e.what());
      return(StatusCode::FAILURE);
   }
   if (!this->cleanUp(outputConnection).isSuccess()) {
      ATH_MSG_ERROR("commitOutput FAILED to cleanup converters.");
      return(StatusCode::FAILURE);
   }
 
   return(StatusCode::SUCCESS);
}

connectOutput() [1/2]

StatusCode AthenaPoolCnvSvc::connectOutput ( const std::string & outputConnectionSpec )

overridevirtual

Implementation of IConversionSvc: Connect to the output connection specification with open mode.

Parameters

outputConnectionSpec

[IN] the name of the output connection specification as string.

Definition at line 235 of file AthenaPoolCnvSvc.cxx.

                                                                                {
// This is called before DataObjects are being converted.
   std::string outputConnection = outputConnectionSpec.substr(0, outputConnectionSpec.find('['));
   unsigned int contextId = outputContextId(outputConnection);
   try {
      if (!m_poolSvc->connect(pool::ITransaction::UPDATE, contextId).isSuccess()) {
         ATH_MSG_ERROR("connectOutput FAILED to open an UPDATE transaction.");
         return(StatusCode::FAILURE);
      }
   } catch (std::exception& e) {
      ATH_MSG_ERROR("connectOutput - caught exception: " << e.what());
      return(StatusCode::FAILURE);
   }
   std::unique_lock<std::mutex> lock(m_mutex);
   if (m_processedContextIds.insert(contextId).second) {
      // Extracting OUTPUT POOL ItechnologySpecificAttributes for Domain, Database and Container.
      extractPoolAttributes(m_poolAttr, &m_containerAttr, &m_databaseAttr, &m_domainAttr);
   }
   if (!processPoolAttributes(m_domainAttr, outputConnection, contextId).isSuccess()) {
      ATH_MSG_DEBUG("connectOutput failed process POOL domain attributes.");
   }
   if (!processPoolAttributes(m_databaseAttr, outputConnection, contextId).isSuccess()) {
      ATH_MSG_DEBUG("connectOutput failed process POOL database attributes.");
   }
   return(StatusCode::SUCCESS);
}

connectOutput() [2/2]

StatusCode AthenaPoolCnvSvc::connectOutput ( const std::string & outputConnectionSpec, const std::string & openMode )

overridevirtual

Implementation of IConversionSvc: Connect to the output connection specification with open mode.

Parameters

outputConnectionSpec	[IN] the name of the output connection specification as string.
openMode	[IN] the open mode of the file as string.

Definition at line 230 of file AthenaPoolCnvSvc.cxx.

                            {
   return(connectOutput(outputConnectionSpec));
}

convertAddress()

StatusCode AthenaPoolCnvSvc::convertAddress ( const IOpaqueAddress * pAddress, std::string & refAddress )

overridevirtual

Convert address to string form.

Parameters

pAddress	[IN] address to be converted.
refAddress	[OUT] converted string form.

Definition at line 395 of file AthenaPoolCnvSvc.cxx.

                               {
   assert(pAddress);
   const TokenAddress* tokAddr = dynamic_cast<const TokenAddress*>(pAddress);
   if (tokAddr != nullptr && tokAddr->getToken() != nullptr) {
      refAddress = tokAddr->getToken()->toString();
   } else {
      refAddress = *pAddress->par();
   }
   return(StatusCode::SUCCESS);
}

createAddress() [1/2]

StatusCode AthenaPoolCnvSvc::createAddress ( long svcType, const CLID & clid, const std::string & refAddress, IOpaqueAddress *& refpAddress )

overridevirtual

Create address from string form.

Parameters

svcType	[IN] service type of the address.
clid	[IN] class id for the address.
refAddress	[IN] string form to be converted.
refpAddress	[OUT] converted address.

Definition at line 383 of file AthenaPoolCnvSvc.cxx.

                                      {
   if (svcType != repSvcType()) {
      ATH_MSG_ERROR("createAddress: svcType != POOL_StorageType " << svcType << " " << repSvcType());
      return(StatusCode::FAILURE);
   }
   refpAddress = new GenericAddress(repSvcType(), clid, refAddress);
   return(StatusCode::SUCCESS);
}

createAddress() [2/2]

StatusCode AthenaPoolCnvSvc::createAddress ( long svcType, const CLID & clid, const std::string * par, const unsigned long * ip, IOpaqueAddress *& refpAddress )

override

Create a Generic address using explicit arguments to identify a single object.

Parameters

svcType	[IN] service type of the address.
clid	[IN] class id for the address.
par	[IN] string containing the database name.
ip	[IN] object identifier.
refpAddress	[OUT] converted address.

Definition at line 353 of file AthenaPoolCnvSvc.cxx.

                                      {
   if( svcType != repSvcType() ) {
      ATH_MSG_ERROR("createAddress: svcType != POOL_StorageType " << svcType << " " << repSvcType());
      return(StatusCode::FAILURE);
   }
   std::unique_ptr<Token> token;
   if (par[0].compare(0, 3, "SHM") == 0) {
      token = std::make_unique<Token>();
      token->setOid(Token::OID_t(ip[0], ip[1]));
      token->setAuxString("[PNAME=" + par[2] + "]");
      RootType classDesc = RootType::ByNameNoQuiet(par[2]);
      token->setClassID(pool::DbReflex::guid(classDesc));
   } else {
      Token *t = m_poolSvc->getToken(par[0], par[1], ip[0]);
      if( t ) {
         token = std::make_unique<Token>(t);
         t->release();
      }
   }
   if (token == nullptr) {
      return(StatusCode::RECOVERABLE);
   }
   refpAddress = new TokenAddress(repSvcType(), clid, "", par[1], IPoolSvc::kInputStream, std::move(token));
   return(StatusCode::SUCCESS);
}

createObj()

StatusCode AthenaPoolCnvSvc::createObj ( IOpaqueAddress * pAddress, DataObject *& refpObject )

overridevirtual

Implementation of IConversionSvc: Create the transient representation of an object from persistent state.

Parameters

pAddress	[IN] pointer to IOpaqueAddress of the representation.
refpObject	[OUT] pointer to DataObject to be created.

Definition at line 134 of file AthenaPoolCnvSvc.cxx.

                                                                                        {
   assert(pAddress);
   std::string objName = "ALL";
   if (m_useDetailChronoStat.value()) {
      if (m_clidSvc->getTypeNameOfID(pAddress->clID(), objName).isFailure()) {
         objName = std::to_string(pAddress->clID());
      }
      objName += '#';
      objName += *(pAddress->par() + 1);
   }
   // StopWatch listens from here until the end of this current scope
   PMonUtils::BasicStopWatch stopWatch("cObj_" + objName, m_chronoMap);
   if (!m_persSvcPerInputType.value().empty()) { // Use separate PersistencySvc for each input data type
      TokenAddress* tokAddr = dynamic_cast<TokenAddress*>(pAddress);
      if (tokAddr != nullptr && tokAddr->getToken() != nullptr && (tokAddr->getToken()->contID().starts_with(m_persSvcPerInputType.value() + "(") || tokAddr->getToken()->contID().starts_with(m_persSvcPerInputType.value() + "_"))) {
         const unsigned int maxContext = m_poolSvc->getInputContextMapSize();
         const unsigned int auxContext = m_poolSvc->getInputContext(tokAddr->getToken()->classID().toString() + tokAddr->getToken()->dbID().toString(), 1);
         if (m_poolSvc->getInputContextMapSize() > maxContext) {
            if (!processPoolAttributes(m_inputAttr, m_lastInputFileName, auxContext, false, true, false).isSuccess()) {
               ATH_MSG_DEBUG("setInputAttribute failed setting POOL database/container attributes.");
            }
         }
         char text[32];
         const std::string contextStr = std::format("[CTXT={:08X}]", auxContext);
         std::strncpy(text, contextStr.c_str(), sizeof(text) - 1);
         text[sizeof(text) - 1] = '\0';
         tokAddr->getToken()->setAuxString(text);
      }
   }
   // Forward to base class createObj
   StatusCode status = ::AthCnvSvc::createObj(pAddress, refpObject);
   return(status);
}

createRep()

StatusCode AthenaPoolCnvSvc::createRep ( DataObject * pObject, IOpaqueAddress *& refpAddress )

overridevirtual

Implementation of IConversionSvc: Convert the transient object to the requested representation.

Parameters

pObject	[IN] pointer to DataObject.
refpAddress	[OUT] pointer to IOpaqueAddress of the representation to be created.

Definition at line 168 of file AthenaPoolCnvSvc.cxx.

                                                                                        {
   assert(pObject);
   std::string objName = "ALL";
   if (m_useDetailChronoStat.value()) {
      if (m_clidSvc->getTypeNameOfID(pObject->clID(), objName).isFailure()) {
         objName = std::to_string(pObject->clID());
      }
      objName += '#';
      objName += pObject->registry()->name();
   }
   // StopWatch listens from here until the end of this current scope
   PMonUtils::BasicStopWatch stopWatch("cRep_" + objName, m_chronoMap);
   StatusCode status = StatusCode::FAILURE;
   if (pObject->clID() == 1) {
      // No transient object was found use cnv to write default persistent object
      SG::DataProxy* proxy = dynamic_cast<SG::DataProxy*>(pObject->registry());
      if (proxy != nullptr) {
         IConverter* cnv = converter(proxy->clID());
         status = cnv->createRep(pObject, refpAddress);
      }
   } else {
      // Forward to base class createRep
      try {
         status = ::AthCnvSvc::createRep(pObject, refpAddress);
      } catch(std::runtime_error& e) {
         ATH_MSG_FATAL(e.what());
      }
   }
   return(status);
}

disconnectOutput()

StatusCode AthenaPoolCnvSvc::disconnectOutput ( const std::string & outputConnectionSpec )

overridevirtual

Disconnect to the output connection.

Definition at line 306 of file AthenaPoolCnvSvc.cxx.

                                                                                   {
   std::string outputConnection = outputConnectionSpec.substr(0, outputConnectionSpec.find('['));
   unsigned int contextId = outputContextId(outputConnection);
   StatusCode sc = m_poolSvc->disconnect(contextId);
   return sc;
}

extractPoolAttributes()

void AthenaPoolCnvSvc::extractPoolAttributes ( const Gaudi::Property< std::vector< std::string > > & property, std::vector< std::vector< std::string > > * contAttr, std::vector< std::vector< std::string > > * dbAttr, std::vector< std::vector< std::string > > * domAttr = 0 ) const

private

Extract POOL ItechnologySpecificAttributes for Domain, Database and Container from property.

Definition at line 467 of file AthenaPoolCnvSvc.cxx.

                                                         {
   std::vector<std::string> opt;
   std::string attributeName, containerName, databaseName, valueString;
   for (const auto& propertyValue : property.value()) {
      opt.clear();
      attributeName.clear();
      containerName.clear();
      databaseName.clear();
      valueString.clear();
      using Gaudi::Utils::AttribStringParser;
      for (const AttribStringParser::Attrib& attrib : AttribStringParser (propertyValue)) {
         if (attrib.tag == "DatabaseName") {
            databaseName = attrib.value;
         } else if (attrib.tag == "ContainerName") {
            if (databaseName.empty()) {
               databaseName = "*";
            }
            containerName = attrib.value;
         } else {
            attributeName = attrib.tag;
            valueString = attrib.value;
         }
      }
      if (!attributeName.empty() && !valueString.empty()) {
         opt.push_back(attributeName);
         opt.push_back(valueString);
         if (!databaseName.empty()) {
            opt.push_back(databaseName);
            if (!containerName.empty()) {
               opt.push_back(containerName);
               if (containerName.compare(0, 6, "TTree=") == 0) {
                  dbAttr->push_back(opt);
               } else {
                  contAttr->push_back(opt);
               }
            } else {
               opt.push_back("");
               dbAttr->push_back(opt);
            }
         } else if (domAttr != 0) {
            domAttr->push_back(opt);
         } else {
            opt.push_back("*");
            opt.push_back("");
            dbAttr->push_back(opt);
         }
      }
   }
}

fillRepRefs()

StatusCode AthenaPoolCnvSvc::fillRepRefs ( IOpaqueAddress * pAddress, DataObject * pObject )

overridevirtual

Implementation of IConversionSvc: Resolve the references of the converted object.

Parameters

pAddress	[IN] pointer to IOpaqueAddress of the representation to be resolved.
pObject	[IN] pointer to DataObject to be created.

Definition at line 199 of file AthenaPoolCnvSvc.cxx.

                                                                                      {
   assert(pObject);
   std::string objName = "ALL";
   if (m_useDetailChronoStat.value()) {
      if (m_clidSvc->getTypeNameOfID(pObject->clID(), objName).isFailure()) {
         objName = std::to_string(pObject->clID());
      }
      objName += '#';
      objName += pObject->registry()->name();
   }
   // StopWatch listens from here until the end of this current scope
   PMonUtils::BasicStopWatch stopWatch("fRep_" + objName, m_chronoMap);
   StatusCode status = StatusCode::FAILURE;
   if (pObject->clID() == 1) {
      // No transient object was found use cnv to write default persistent object
      SG::DataProxy* proxy = dynamic_cast<SG::DataProxy*>(pObject->registry());
      if (proxy != nullptr) {
         IConverter* cnv = converter(proxy->clID());
         status = cnv->fillRepRefs(pAddress, pObject);
      }
   } else {
      // Forward to base class fillRepRefs
      try {
         status = ::AthCnvSvc::fillRepRefs(pAddress, pObject);
      } catch(std::runtime_error& e) {
         ATH_MSG_FATAL(e.what());
      }
   }
   return(status);
}

finalize()

StatusCode AthenaPoolCnvSvc::finalize ( )

overridevirtual

Required of all Gaudi Services.

Definition at line 100 of file AthenaPoolCnvSvc.cxx.

                                      {
   ATH_MSG_VERBOSE("Finalizing...");
   // Some algorithms write in finalize(), flush DHForms if any are left
   flushDataHeaderForms();
   // Release ClassIDSvc
   if (!m_clidSvc.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release ClassIDSvc.");
   }
   // Release PoolSvc
   if (!m_poolSvc.release().isSuccess()) {
      ATH_MSG_WARNING("Cannot release PoolSvc.");
   }
   // Print Performance Statistics
   // The pattern AthenaPoolCnvSvc.*PerfStats is ignored in AtlasTest/TestTools/share/post.sh
   const std::string msgPrefix{"PerfStats "};
   ATH_MSG_INFO(msgPrefix << std::string(40, '-'));
   ATH_MSG_INFO(msgPrefix << "Timing Measurements for AthenaPoolCnvSvc");
   ATH_MSG_INFO(msgPrefix << std::string(40, '-'));
   for(const auto& [key, value] : m_chronoMap) {
      ATH_MSG_INFO(msgPrefix << "| " << std::left << std::setw(15) << key << " | "
                        << std::right << std::setw(15) << std::fixed << std::setprecision(0) << value << " ms |");
   }
   ATH_MSG_INFO(msgPrefix << std::string(40, '-'));
 
   m_cnvs.clear();
   m_cnvs.shrink_to_fit();
   return(StatusCode::SUCCESS);
}

flushDataHeaderForms()

void AthenaPoolCnvSvc::flushDataHeaderForms

(

const std::string &

streamName = "*"

)

Tell DataHeaderCnv to write out all DataHeaderForms for a given streamName (default is all).

Definition at line 86 of file AthenaPoolCnvSvc.cxx.

                                                                       {
   // Write remaining DataHeaderForms for a given streamName, "*"" means all
   auto DHCnvListener = dynamic_cast<IIncidentListener*>( converter( ClassID_traits<DataHeader>::ID() ) );
   FileIncident incident(name(), "WriteDataHeaderForms", streamName);
   if( DHCnvListener ) DHCnvListener->handle(incident);
}

getPoolSvc()

IPoolSvc * AthenaPoolCnvSvc::getPoolSvc ( )

overridevirtual

Returns

pointer to PoolSvc instance.

Definition at line 320 of file AthenaPoolCnvSvc.cxx.

                                       {
   return(&*m_poolSvc);
}

handle()

void AthenaPoolCnvSvc::handle ( const Incident & incident )

overridevirtual

Implementation of IIncidentListener: Handle for EndEvent incidence.

Definition at line 455 of file AthenaPoolCnvSvc.cxx.

                                                      {
   if (incident.type() == "EndEvent") {
      if (!processPoolAttributes(m_inputAttrPerEvent, m_lastInputFileName, IPoolSvc::kInputStream).isSuccess()) {
         ATH_MSG_DEBUG("handle EndEvent failed process POOL database attributes.");
      }
   }
}

initialize()

StatusCode AthenaPoolCnvSvc::initialize ( )

overridevirtual

Required of all Gaudi Services.

Definition at line 35 of file AthenaPoolCnvSvc.cxx.

                                        {
   // Retrieve PoolSvc
   ATH_CHECK(m_poolSvc.retrieve());
   // Retrieve ClassIDSvc
   ATH_CHECK(m_clidSvc.retrieve());
   // Register this service for 'I/O' events
   ServiceHandle<IIoComponentMgr> iomgr("IoComponentMgr", name());
   ATH_CHECK(iomgr.retrieve());
   if (!iomgr->io_register(this).isSuccess()) {
      ATH_MSG_FATAL("Could not register myself with the IoComponentMgr !");
      return(StatusCode::FAILURE);
   }
   // Global POOL container naming scheme
   if (auto scheme = APRDefaults::WriteConfig::parseNamingScheme(m_containerNamingSchemeProp.value())) {
      APRDefaults::WriteConfig::setNamingScheme(*scheme);
   } else {
      ATH_MSG_ERROR(std::format("Invalid PoolContainerNamingScheme: {}, see APRDefaults.h for the full list.", m_containerNamingSchemeProp.value()));
      return StatusCode::FAILURE;
   }
   // Extracting INPUT POOL ItechnologySpecificAttributes for Domain, Database and Container.
   extractPoolAttributes(m_inputPoolAttr, &m_inputAttr, &m_inputAttr, &m_inputAttr);
   // Extracting the INPUT POOL ItechnologySpecificAttributes which are to be printed for each event
   extractPoolAttributes(m_inputPoolAttrPerEvent, &m_inputAttrPerEvent, &m_inputAttrPerEvent, &m_inputAttrPerEvent);
   // Setup incident for EndEvent to print out attributes each event
   ServiceHandle<IIncidentSvc> incSvc("IncidentSvc", name());
   long int pri = 1000;
   if (!m_inputPoolAttrPerEvent.value().empty()) {
      // Set to be listener for EndEvent
      incSvc->addListener(this, "EndEvent", pri);
      ATH_MSG_DEBUG("Subscribed to EndEvent for printing out input file attributes.");
   }
   if (!processPoolAttributes(m_inputAttr, "", IPoolSvc::kInputStream, false, true, true).isSuccess()) {
      ATH_MSG_DEBUG("setInputAttribute failed setting POOL domain attributes.");
   }
 
   // Load these dictionaries now, so we don't need to try to do so
   // while multiple threads are running.
   TClass::GetClass ("TLeafI");
   TClass::GetClass ("TLeafL");
   TClass::GetClass ("TLeafD");
   TClass::GetClass ("TLeafF");
 
   return(StatusCode::SUCCESS);
}

io_finalize()

StatusCode AthenaPoolCnvSvc::io_finalize ( )

overridevirtual

Definition at line 129 of file AthenaPoolCnvSvc.cxx.

                                         {
   ATH_MSG_DEBUG("I/O finalization...");
   return(StatusCode::SUCCESS);
}

io_reinit()

StatusCode AthenaPoolCnvSvc::io_reinit ( )

overridevirtual

Definition at line 80 of file AthenaPoolCnvSvc.cxx.

                                       {
   ATH_MSG_DEBUG("I/O reinitialization...");
   m_processedContextIds.clear();
   return(StatusCode::SUCCESS);
}

outputContextId()

unsigned int AthenaPoolCnvSvc::outputContextId ( const std::string & outputConnection )

protected

Definition at line 314 of file AthenaPoolCnvSvc.cxx.

                                                                                {
   return m_persSvcPerOutput?
      m_poolSvc->getOutputContext(outputConnection) : (unsigned int)IPoolSvc::kOutputStream;
}

processPoolAttributes()

StatusCode AthenaPoolCnvSvc::processPoolAttributes ( std::vector< std::vector< std::string > > & attr, const std::string & fileName, unsigned long contextId, bool doGet = true, bool doSet = true, bool doClear = true ) const

private

Set/get technology dependent POOL attributes.

Definition at line 520 of file AthenaPoolCnvSvc.cxx.

                            {
   bool retError = false;
   for (auto& attrEntry : attr) {
      if (attrEntry.size() == 2) {
         const std::string& opt = attrEntry[0];
         std::string data = attrEntry[1];
         if (data == "int" || data == "DbLonglong" || data == "double" || data == "string") {
            if (doGet) {
               if (!m_poolSvc->getAttribute(opt, data, pool::DbType(pool::ROOTTREE_StorageType).type(), contextId).isSuccess()) {
                  ATH_MSG_DEBUG("getAttribute failed for domain attr " << opt);
                  retError = true;
               }
            }
         } else if (doSet) {
            if (m_poolSvc->setAttribute(opt, data, pool::DbType(pool::ROOTTREE_StorageType).type(), contextId).isSuccess()) {
               ATH_MSG_DEBUG("setAttribute " << opt << " to " << data);
               if (doClear) {
                  attrEntry.clear();
               }
            } else {
               ATH_MSG_DEBUG("setAttribute failed for domain attr " << opt << " to " << data);
               retError = true;
            }
         }
      }
      if (attrEntry.size() == 4) {
         const std::string& opt = attrEntry[0];
         std::string data = attrEntry[1];
         const std::string& file = attrEntry[2];
         const std::string& cont = attrEntry[3];
         if (!fileName.empty() && (0 == fileName.compare(0, fileName.find('?'), file)
             || (file[0] == '*' && file.find("," + fileName + ",") == std::string::npos))) {
            if (data == "int" || data == "DbLonglong" || data == "double" || data == "string") {
               if (doGet) {
                  if (!m_poolSvc->getAttribute(opt, data, pool::DbType(pool::ROOTTREE_StorageType).type(), fileName, cont, contextId).isSuccess()) {
                     ATH_MSG_DEBUG("getAttribute failed for database/container attr " << opt);
                     retError = true;
                  }
               }
            } else if (doSet) {
               if (m_poolSvc->setAttribute(opt, data, pool::DbType(pool::ROOTTREE_StorageType).type(), fileName, cont, contextId).isSuccess()) {
                  ATH_MSG_DEBUG("setAttribute " << opt << " to " << data << " for db: " << fileName << " and cont: " << cont);
                  if (doClear) {
                     if (file[0] == '*' && !m_persSvcPerOutput) {
                        attrEntry[2] += "," + fileName + ",";
                     } else {
                        attrEntry.clear();
                     }
                  }
               } else {
                  ATH_MSG_DEBUG("setAttribute failed for " << opt << " to " << data << " for db: " << fileName << " and cont: " << cont);
                  retError = true;
               }
            }
         }
      }
   }
   std::erase_if(attr, [](const auto& entry) { return entry.empty(); });
   return(retError ? StatusCode::FAILURE : StatusCode::SUCCESS);
}

registerCleanUp()

StatusCode AthenaPoolCnvSvc::registerCleanUp ( IAthenaPoolCleanUp * cnv )

overridevirtual

Implement registerCleanUp to register a IAthenaPoolCleanUp to be called during cleanUp.

Definition at line 407 of file AthenaPoolCnvSvc.cxx.

                                                                    {
   m_cnvs.push_back(cnv);
   return(StatusCode::SUCCESS);
}

registerForWrite()

Token * AthenaPoolCnvSvc::registerForWrite ( Placement * placement, const void * obj, const RootType & classDesc )

overridevirtual

Returns

a string token to a Data Object written to Pool

Parameters

placement	[IN] pointer to the placement hint
obj	[IN] pointer to the Data Object to be written to Pool
classDesc	[IN] pointer to the Seal class description for the Data Object.

Definition at line 324 of file AthenaPoolCnvSvc.cxx.

                                                                                                          {
   // StopWatch listens from here until the end of this current scope
   PMonUtils::BasicStopWatch stopWatch("cRepR_ALL", m_chronoMap);
   Token* token = nullptr;
         if (m_persSvcPerOutput) { // Use separate PersistencySvc for each output stream/file
            char text[32];
            const std::string contextStr = std::format("[CTXT={:08X}]", m_poolSvc->getOutputContext(placement->fileName()));
            std::strncpy(text, contextStr.c_str(), sizeof(text) - 1);
            text[sizeof(text) - 1] = '\0';
            placement->setAuxString(text);
         }
         token = m_poolSvc->registerForWrite(placement, obj, classDesc);
   return(token);
}

setInputAttributes()

StatusCode AthenaPoolCnvSvc::setInputAttributes ( const std::string & fileName )

overridevirtual

Set the input file attributes, if any are requested from jobOpts.

Parameters

fileName

[IN] name of the input file

Definition at line 433 of file AthenaPoolCnvSvc.cxx.

                                                                         {
   // Set attributes for input file
   m_lastInputFileName = fileName; // Save file name for printing attributes per event
   if (!m_persSvcPerInputType.empty()) {
// Loop over all extra event input contexts
      const auto& extraInputContextMap = m_poolSvc->getInputContextMap();
      for (const auto& [label, id]: extraInputContextMap) {
         if (!processPoolAttributes(m_inputAttr, m_lastInputFileName, id, false, true, false).isSuccess()) {
            ATH_MSG_DEBUG("setInputAttribute failed setting POOL database/container attributes.");
         }
      }
   }
   if (!processPoolAttributes(m_inputAttr, m_lastInputFileName, IPoolSvc::kInputStream, false, true, false).isSuccess()) {
      ATH_MSG_DEBUG("setInputAttribute failed setting POOL database/container attributes.");
   }
   if (!processPoolAttributes(m_inputAttr, m_lastInputFileName, IPoolSvc::kInputStream, true, false).isSuccess()) {
      ATH_MSG_DEBUG("setInputAttribute failed getting POOL database/container attributes.");
   }
   return(StatusCode::SUCCESS);
}

setObjPtr()

void AthenaPoolCnvSvc::setObjPtr ( void *& obj, const Token * token )

overridevirtual

Parameters

obj	[OUT] pointer to the Data Object.
token	[IN] string token of the Data Object for which a Pool Ref is filled.

Definition at line 339 of file AthenaPoolCnvSvc.cxx.

                                                               {
   ATH_MSG_VERBOSE("Requesting object for: " << token->toString());
   // StopWatch listens from here until the end of this current scope
   PMonUtils::BasicStopWatch stopWatch("cObjR_ALL", m_chronoMap);
   if (token->dbID() != Guid::null()) {
      ATH_MSG_VERBOSE("Requesting object for: " << token->toString());
      m_poolSvc->setObjPtr(obj, token);
   }
}

stop()

StatusCode AthenaPoolCnvSvc::stop ( )

overridevirtual

Definition at line 93 of file AthenaPoolCnvSvc.cxx.

                                  {
   ATH_MSG_VERBOSE("stop()");
   // In case of direct writing without an OutputStream, this should be a good time to flush DHForms
   flushDataHeaderForms();
   return StatusCode::SUCCESS;
}

useDetailChronoStat()

bool AthenaPoolCnvSvc::useDetailChronoStat ( ) const

overridevirtual

Returns

a boolean for using detailed time and size statistics.

Definition at line 349 of file AthenaPoolCnvSvc.cxx.

                                                 {
   return(m_useDetailChronoStat.value());
}

Friends And Related Symbol Documentation

SvcFactory< AthenaPoolCnvSvc >

friend class SvcFactory< AthenaPoolCnvSvc >

friend

Definition at line 1 of file AthenaPoolCnvSvc.h.

Member Data Documentation

m_chronoMap

PMonUtils::BasicStopWatchResultMap_t AthenaPoolCnvSvc::m_chronoMap {}

protected

Map that holds chrono information.

Definition at line 177 of file AthenaPoolCnvSvc.h.

{};

m_clidSvc

ServiceHandle<IClassIDSvc> AthenaPoolCnvSvc::m_clidSvc {this,"ClassIDSvc","ClassIDSvc"}

private

Definition at line 173 of file AthenaPoolCnvSvc.h.

{this,"ClassIDSvc","ClassIDSvc"};

m_containerAttr

std::vector<std::vector<std::string> > AthenaPoolCnvSvc::m_containerAttr

private

Definition at line 191 of file AthenaPoolCnvSvc.h.

m_containerNamingSchemeProp

Gaudi::Property<std::string> AthenaPoolCnvSvc::m_containerNamingSchemeProp {this, "PoolContainerNamingScheme", "Historical"}

private

POOL container naming scheme selection.

Definition at line 185 of file AthenaPoolCnvSvc.h.

{this, "PoolContainerNamingScheme", "Historical"};

m_databaseAttr

std::vector<std::vector<std::string> > AthenaPoolCnvSvc::m_databaseAttr

private

Definition at line 190 of file AthenaPoolCnvSvc.h.

m_DHFilterAliases

Gaudi::Property<bool> AthenaPoolCnvSvc::m_DHFilterAliases { this, "doFilterDHAliases", true }

protected

Flag to control SG alias filtering when writing out DataHeader (see DataHeaderCnv_p6).

Definition at line 222 of file AthenaPoolCnvSvc.h.

{ this, "doFilterDHAliases", true };

m_DHFormCacheSize

Gaudi::Property<int> AthenaPoolCnvSvc::m_DHFormCacheSize { this, "maxDHFormCacheSize", 100 }

protected

Property for DataHeaderCnv input DHForm cache size.

Definition at line 219 of file AthenaPoolCnvSvc.h.

{ this, "maxDHFormCacheSize", 100 };

m_domainAttr

std::vector<std::vector<std::string> > AthenaPoolCnvSvc::m_domainAttr

private

Definition at line 189 of file AthenaPoolCnvSvc.h.

m_inputAttr

std::vector<std::vector<std::string> > AthenaPoolCnvSvc::m_inputAttr

private

Definition at line 195 of file AthenaPoolCnvSvc.h.

m_inputAttrPerEvent

std::vector<std::vector<std::string> > AthenaPoolCnvSvc::m_inputAttrPerEvent

private

Definition at line 199 of file AthenaPoolCnvSvc.h.

m_inputPoolAttr

Gaudi::Property<std::vector<std::string> > AthenaPoolCnvSvc::m_inputPoolAttr {this,"InputPoolAttributes",{}}

private

Input PoolAttributes, vector with names and values of technology specific attributes for POOL.

Definition at line 194 of file AthenaPoolCnvSvc.h.

{this,"InputPoolAttributes",{}};

m_inputPoolAttrPerEvent

Gaudi::Property<std::vector<std::string> > AthenaPoolCnvSvc::m_inputPoolAttrPerEvent {this,"PrintInputAttrPerEvt",{}}

private

Print input PoolAttributes per event, vector with names of technology specific attributes for POOL to be printed each event.

Definition at line 198 of file AthenaPoolCnvSvc.h.

{this,"PrintInputAttrPerEvt",{}};

m_lastInputFileName

std::string AthenaPoolCnvSvc::m_lastInputFileName

private

decoded storage tech requested in "StorageTechnology" property

Definition at line 171 of file AthenaPoolCnvSvc.h.

m_mutex

std::mutex AthenaPoolCnvSvc::m_mutex

protected

Definition at line 210 of file AthenaPoolCnvSvc.h.

m_oneDataHeaderForm

Gaudi::Property<bool> AthenaPoolCnvSvc::m_oneDataHeaderForm { this, "OneDataHeaderForm", false }

protected

If true, use only one DataHeaderForm per Stream.

Definition at line 216 of file AthenaPoolCnvSvc.h.

{ this, "OneDataHeaderForm", false };

m_persSvcPerInputType

Gaudi::Property<std::string> AthenaPoolCnvSvc::m_persSvcPerInputType {this,"PersSvcPerInputType",""}

protected

PersSvcPerInputType, string property, tree name to use multiple persistency services, one per input type.

default = "", no tree name results in a single persistency service.

Definition at line 209 of file AthenaPoolCnvSvc.h.

{this,"PersSvcPerInputType",""};

m_persSvcPerOutput

Gaudi::Property<bool> AthenaPoolCnvSvc::m_persSvcPerOutput {this,"PersSvcPerOutput",true}

protected

PersSvcPerOutput, boolean property to use multiple persistency services, one per output stream.

default = true.

Definition at line 204 of file AthenaPoolCnvSvc.h.

{this,"PersSvcPerOutput",true};

m_poolAttr

Gaudi::Property<std::vector<std::string> > AthenaPoolCnvSvc::m_poolAttr {this,"PoolAttributes",{},"Pool Attributes","OrderedSet<std::string>"}

private

Output PoolAttributes, vector with names and values of technology specific attributes for POOL.

Definition at line 188 of file AthenaPoolCnvSvc.h.

{this,"PoolAttributes",{},"Pool Attributes","OrderedSet<std::string>"};

m_poolSvc

ServiceHandle<IPoolSvc> AthenaPoolCnvSvc::m_poolSvc {this,"PoolSvc","PoolSvc"}

private

Definition at line 172 of file AthenaPoolCnvSvc.h.

{this,"PoolSvc","PoolSvc"};

m_processedContextIds

std::set<unsigned int> AthenaPoolCnvSvc::m_processedContextIds

protected

Track context IDs for which extractPoolAttributes has been called.

Definition at line 213 of file AthenaPoolCnvSvc.h.

m_useDetailChronoStat

Gaudi::Property<bool> AthenaPoolCnvSvc::m_useDetailChronoStat {this,"UseDetailChronoStat",false}

private

UseDetailChronoStat, enable detailed output for time and size statistics for AthenaPOOL: default = false.

Definition at line 182 of file AthenaPoolCnvSvc.h.

{this,"UseDetailChronoStat",false};

---

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

• AthenaPoolCnvSvc.h
• AthenaPoolCnvSvc.cxx