PoolSvc Class Reference

This class provides the interface to the LCG POOL persistency software. More...

#include <PoolSvc.h>

Inheritance diagram for PoolSvc:

Collaboration diagram for PoolSvc:

Classes
class	ContextLock

Public Member Functions
virtual StatusCode	initialize () override
	Required of all Gaudi services:
virtual StatusCode	io_reinit () override
virtual StatusCode	start () override
	Required of all Gaudi services:
virtual StatusCode	stop () override
virtual StatusCode	finalize () override
	Required of all Gaudi services:
virtual StatusCode	io_finalize () override
virtual Token *	registerForWrite (const Placement *placement, const void *obj, const RootType &classDesc) override
virtual void	setObjPtr (void *&obj, const Token *token) override
virtual unsigned int	getOutputContext (const std::string &label) override
virtual unsigned int	getInputContext (const std::string &label, unsigned int maxFile=0) override
virtual std::map< std::string, unsigned int >	getInputContextMap () const override
virtual unsigned int	getInputContextMapSize () const override
virtual pool::FileDescriptor	getInputFileDescriptor (unsigned int contextId, const std::string &connection) override
virtual void	setShareMode (bool shareCat) override
virtual void	startCatalog () override
virtual void	commitCatalog () override
virtual void	lookupBestPfn (const std::string &dbID, std::string &pfn, std::string &type) const override
virtual StatusCode	connectCollection (const std::string &connection, const std::string &collectionName, unsigned int contextId=IPoolSvc::kInputStream) override
virtual StatusCode	checkCollection (const std::string &connection, unsigned int contextId, bool noContainer) override
virtual Token *	getToken (const std::string &connection, const std::string &collection, const unsigned long ientry) override
virtual StatusCode	connect (Io::IoFlag type, unsigned int contextId=IPoolSvc::kInputStream) override
	Connect to a logical database unit; PersistencySvc is chosen according to transaction type (accessmode).
virtual StatusCode	commit (unsigned int contextId=IPoolSvc::kInputStream) override
	Commit data for a given contextId and flush buffer.
virtual StatusCode	commitAndHold (unsigned int contextId=IPoolSvc::kInputStream) override
	Commit data for a given contextId and hold buffer.
virtual StatusCode	disconnect (unsigned int contextId=IPoolSvc::kInputStream) override
	Disconnect PersistencySvc associated with a contextId.
virtual StatusCode	disconnectDb (const std::string &connection, unsigned int contextId=IPoolSvc::kInputStream) override
	Disconnect single Database.
virtual StatusCode	getAttribute (const std::string &optName, std::string &data, long tech, unsigned int contextId=IPoolSvc::kInputStream) override
	Get POOL attributes - domain.
virtual StatusCode	getAttribute (const std::string &optName, std::string &data, long tech, const std::string &dbName, const std::string &contName="", unsigned int contextId=IPoolSvc::kInputStream) override
	Get POOL attributes - db/file, container/collection.
virtual StatusCode	setAttribute (const std::string &optName, const std::string &data, long tech, unsigned int contextId=IPoolSvc::kOutputStream) override
	Set POOL attributes - domain.
virtual StatusCode	setAttribute (const std::string &optName, const std::string &data, long tech, const std::string &dbName, const std::string &contName="", unsigned int contextId=IPoolSvc::kOutputStream) override
	Set POOL attributes - db/file, container/collection.
StatusCode	createSession (const std::string &sessionName, int ageLimit=-1)
	Create a new session for a given session name and age limit.
virtual	~PoolSvc ()
	Destructor.

Private Types
using	CallMutex = std::recursive_mutex

Private Member Functions
void	clearState ()
bool	createCatalog ()
void	patchCatalog (const std::string &pfn, pool::IDatabase &dbH) const
StatusCode	setupPersistencySvc ()
std::unique_ptr< pool::IDatabase >	getDbHandle (unsigned int contextId, const std::string &dbName)
	Get Database handle.
std::unique_ptr< pool::IContainer >	getContainerHandle (pool::IDatabase *dbH, const std::string &contName)
	Get Container handle.
std::string	poolCondPath (const std::string &leaf)
	Resolve a file using ATLAS_POOLCOND_PATH.

Private Attributes
CallMutex	m_pool_mut
bool	m_shareCat {false}
SmartIF< Gaudi::IFileCatalogMgr >	m_catalogMgr
SmartIF< Gaudi::IFileCatalog >	m_catalog
std::vector< ToolHandle< SessionTool > >	m_dbSessionVec
std::vector< CallMutex * >	m_pers_mut
std::map< std::string, unsigned int >	m_inputContextLabel
std::map< std::string, unsigned int >	m_outputContextLabel
std::string	m_mainOutputLabel {}
std::map< unsigned int, unsigned int >	m_contextMaxFile
std::map< unsigned int, std::list< Guid > > m_guidLists	ATLAS_THREAD_SAFE
Gaudi::Property< int >	m_dbAgeLimit {this,"MaxFilesOpen",0}
	MaxFilesOpen, option to have PoolSvc limit the number of open Input Files: default = 0 (No files are closed automatically).
Gaudi::Property< std::string >	m_writeCatalog {this,"WriteCatalog","xmlcatalog_file:PoolFileCatalog.xml"}
	WriteCatalog, the file catalog to be used to register output files (also default input catalog): default = "" (use POOL default).
Gaudi::Property< std::vector< std::string > >	m_readCatalog {this,"ReadCatalog",{},"List of catalog files to read from","OrderedSet<std::string>"}
	ReadCatalog, the list of additional POOL input file catalogs to consult: default = empty vector.
Gaudi::Property< bool >	m_useROOTIMT {this,"UseROOTImplicitMT",true}
	Use ROOT Implicit MultiThreading, default = true.
Gaudi::Property< bool >	m_useROOTMaxTree {this,"UseROOTIncreaseVMaxTree",false}
	Increase virtual TTree size to avoid backreads in multithreading, default = false.
Gaudi::Property< bool >	m_attemptCatalogPatch {this,"AttemptCatalogPatch",true}
	AttemptCatalogPatch, option to create catalog: default = false.

Detailed Description

This class provides the interface to the LCG POOL persistency software.

Definition at line 38 of file PoolSvc.h.

Member Typedef Documentation

CallMutex

using PoolSvc::CallMutex = std::recursive_mutex

private

Definition at line 207 of file PoolSvc.h.

Constructor & Destructor Documentation

~PoolSvc()

PoolSvc::~PoolSvc ( )

virtual

Destructor.

Definition at line 815 of file PoolSvc.cxx.

                  {
}

Member Function Documentation

checkCollection()

StatusCode PoolSvc::checkCollection ( const std::string & connection, unsigned int contextId, bool noContainer )

overridevirtual

Returns

status of check

Parameters

connection	[IN] string containing the connection.
contextId	[IN] id for PoolSvc persistency service to use for input.
noContainer	[IN] if no collection was found check whether file exists or had no events

Definition at line 439 of file PoolSvc.cxx.

                                  {
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   std::unique_ptr<pool::IDatabase> dbH = getDbHandle(contextId, connection);
   if (dbH != nullptr && !dbH->fid().empty()) {
      if (noContainer) {
         return(StatusCode::SUCCESS); // no events
      }
      if (m_attemptCatalogPatch.value()) {
         patchCatalog(connection.substr(4), *dbH);
      }
      return(StatusCode::SUCCESS);
   }
   return(StatusCode::FAILURE);
}

clearState()

void PoolSvc::clearState ( )

private

Definition at line 181 of file PoolSvc.cxx.

                         {
   std::lock_guard<CallMutex> lock(m_pool_mut);
   // Cleanup persistency service
   // Tools are kept forever, hopefully closing sessions will be enough
   for( auto& session : m_dbSessionVec ) {
      session->closeSession();
   }
   m_dbSessionVec.clear();
   for (const auto& persistencyMutex : m_pers_mut) {
      delete persistencyMutex;
   }
   m_mainOutputLabel.clear();
   m_inputContextLabel.clear();
   m_outputContextLabel.clear();
   m_pers_mut.clear();
   if (m_catalog.isValid()) {
      m_catalog->commit();
      m_catalog = SmartIF<Gaudi::IFileCatalog>();
      m_catalogMgr = SmartIF<Gaudi::IFileCatalogMgr>();
   }
}

commit()

StatusCode PoolSvc::commit ( unsigned int contextId = IPoolSvc::kInputStream )

overridevirtual

Commit data for a given contextId and flush buffer.

Parameters

contextId

[IN] poolStream to be commited.

Definition at line 512 of file PoolSvc.cxx.

                                                 {
   if (contextId >= m_dbSessionVec.size()) {
      return StatusCode::FAILURE;
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   auto& session = m_dbSessionVec[contextId];
   if( session->openMode() != Io::INVALID && !session->commit() ) {
      ATH_MSG_ERROR("POOL commit failed " << session);
      return StatusCode::FAILURE;
   }
   if (session->openMode() == Io::READ) {
      session->disconnectAll();
   }
   return StatusCode::SUCCESS;
}

commitAndHold()

StatusCode PoolSvc::commitAndHold ( unsigned int contextId = IPoolSvc::kInputStream )

overridevirtual

Commit data for a given contextId and hold buffer.

Parameters

contextId

[IN] poolStream to be commited.

Definition at line 528 of file PoolSvc.cxx.

                                                        {
   if (contextId >= m_dbSessionVec.size()) {
      return StatusCode::FAILURE;
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   auto& session = m_dbSessionVec[contextId];
   if( session->openMode() != Io::INVALID && !session->commitAndHold() ) {
      ATH_MSG_ERROR("POOL commitAndHold failed " << session);
      return StatusCode::FAILURE;
   }
   return StatusCode::SUCCESS;
}

commitCatalog()

void PoolSvc::commitCatalog ( )

overridevirtual

Returns

void

Definition at line 371 of file PoolSvc.cxx.

                            {
   if (m_catalog.isValid()) {
      m_catalog->commit();
   }
}

connect()

StatusCode PoolSvc::connect ( Io::IoFlag type, unsigned int contextId = IPoolSvc::kInputStream )

overridevirtual

Connect to a logical database unit; PersistencySvc is chosen according to transaction type (accessmode).

Definition at line 484 of file PoolSvc.cxx.

                                                                 {
   if (type != Io::READ) {
      if (contextId >= m_dbSessionVec.size()) {
         ATH_MSG_WARNING("connect: Using default output Stream instead of id = " << contextId);
         contextId = IPoolSvc::kOutputStream;
      }
   } else {
      if (contextId > m_dbSessionVec.size()) {
         ATH_MSG_WARNING("connect: Using default input Stream instead of id = " << contextId);
         contextId = IPoolSvc::kInputStream;
      } else if (contextId == m_dbSessionVec.size()) {
         ATH_MSG_INFO("Connecting to InputStream for: " << contextId);
         contextId = this->getInputContext("");
      }
   }
   if (contextId >= m_dbSessionVec.size()) {
      return StatusCode::FAILURE;
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   auto& session = m_dbSessionVec[contextId];
   // Connect to a logical database using the pre-defined technology and dbID
   if( session->openMode() == Io::INVALID && !session->start(type) ) {
      ATH_MSG_ERROR("connect failed session = " << session << " type = " << type);
      return StatusCode::FAILURE;
   }
   return StatusCode::SUCCESS;
}

connectCollection()

StatusCode PoolSvc::connectCollection ( const std::string & connection, const std::string & collectionName, unsigned int contextId = IPoolSvc::kInputStream )

overridevirtual

Returns

status of connect

Parameters

connection	[IN] string containing the connection.
collectionName	[IN] string containing the persistent name of the collection.
contextId	[IN] id for PoolSvc persistency service to use for input.

Definition at line 381 of file PoolSvc.cxx.

{
   ATH_MSG_DEBUG("connectCollection() connection=" << connection
                 << ", name=" << collectionName << ", contextID=" << contextId);
   if (contextId >= m_dbSessionVec.size()) {
      ATH_MSG_WARNING("connectCollection: Using default input Stream instead of id = " << contextId);
      contextId = IPoolSvc::kInputStream;
   }
 
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   // Check POOL FileCatalog entry.
   bool insertFile = false;
   if (connection.starts_with("PFN:")) {
      std::string fid, fileType;
      FileCatalogUtils::lookupFileByPFN(*m_catalog, connection.substr(4), fid, fileType);
      if (fid.empty()) { // No entry in file catalog
         insertFile = true;
         ATH_MSG_INFO("File is not in Catalog! Attempt to open it anyway.");
      }
   }
 
   // Check whether Collection Container exists.
   std::unique_ptr<pool::IDatabase> dbH = getDbHandle(contextId, connection);
   if( !dbH ) {
      ATH_MSG_INFO("connectCollection(): Failed to get Database Handle for: " << connection);
      return StatusCode::FAILURE;
   }
   try {
      if (dbH->openMode() == Io::INVALID) {
         dbH->connectForRead();
      }
      std::map<unsigned int, unsigned int>::const_iterator maxFileIter = m_contextMaxFile.find(contextId);
      if (maxFileIter != m_contextMaxFile.end() && maxFileIter->second > 0 && !dbH->fid().empty()) {
         const Guid guid(dbH->fid());
         m_guidLists[contextId].remove(guid);
         m_guidLists[contextId].push_back(guid);
         while (m_guidLists[contextId].size() > maxFileIter->second + 1) {
            this->disconnectDb("FID:" + m_guidLists[contextId].begin()->toString(), contextId).ignore();
         }
      }
   } catch (std::exception& e) {
      ATH_MSG_INFO("connectCollection() failed to open '" << connection << "' - trying.");
   }
   // For multithreaded processing (with multiple events in flight),
   // increase virtual tree size to accomodate back reads
   if (m_useROOTMaxTree && contextId == IPoolSvc::kInputStream && Gaudi::Concurrency::ConcurrencyFlags::numConcurrentEvents() > 1) {
      ATH_MSG_DEBUG("connectCollection(): Increasing virtual TTree size for: " << connection);
      if (!this->setAttribute("TREE_MAX_VIRTUAL_SIZE", "-1", pool::ROOT_StorageType.type(), connection.substr(4), "CollectionTree", contextId).isSuccess()) {
         ATH_MSG_DEBUG("Failed to increase maximum virtual TTree size.");
      }
   }
   if (insertFile) return(StatusCode::RECOVERABLE);
 
   return(StatusCode::SUCCESS);
}

createCatalog()

bool PoolSvc::createCatalog ( )

private

Definition at line 769 of file PoolSvc.cxx.

                            {
   m_catalogMgr = Gaudi::svcLocator()->service<Gaudi::IFileCatalogMgr>("Gaudi::MultiFileCatalog");
   m_catalog = SmartIF<Gaudi::IFileCatalog>(m_catalogMgr);
   if (!m_catalogMgr.isValid() || !m_catalog.isValid()) {
      return false;
   }
   // set the output level of the XMLCatalog component - works only if the Gaudi AppMgr was initialized
   Gaudi::svcLocator()->service<IMessageSvc>("MessageSvc")
      ->setOutputLevel("XMLCatalog", pool::DbPrint::getOutputLvl());
   m_catalogMgr->removeCatalog("*");
   for (auto& catalog : m_readCatalog.value()) {
      ATH_MSG_DEBUG("POOL ReadCatalog is " << catalog);
      if (catalog.starts_with("apcfile:") || catalog.starts_with("prfile:")) {
         std::string::size_type cpos = catalog.find(':');
         // check for file accessed via ATLAS_POOLCOND_PATH
         std::string file = poolCondPath(catalog.substr(cpos + 1));
         if (!file.empty()) {
            ATH_MSG_INFO("Resolved path (via ATLAS_POOLCOND_PATH) is " << file);
            FileCatalogUtils::addCatalog(*m_catalogMgr, "file:" + file);
         } else {
            // As backup, check for file accessed via PathResolver
            file = PathResolver::find_file(catalog.substr(cpos + 1), "DATAPATH");
            if (!file.empty()) {
               ATH_MSG_INFO("Resolved path (via DATAPATH) is " << file);
               FileCatalogUtils::addCatalog(*m_catalogMgr, "file:" + file);
            } else {
               ATH_MSG_INFO("Unable find catalog "
                   << catalog
                   << " in $ATLAS_POOLCOND_PATH and $DATAPATH");
            }
         }
      } else {
         FileCatalogUtils::addCatalog(*m_catalogMgr, catalog);
      }
   }
   try {
      ATH_MSG_INFO("POOL WriteCatalog is " << m_writeCatalog.value());
      FileCatalogUtils::addCatalog(*m_catalogMgr, m_writeCatalog.value(), true);
   } catch(std::exception& e) {
      ATH_MSG_ERROR("setWriteCatalog - caught exception: " << e.what());
      return false; // This catalog is not setup properly!
   }
   return true;
}

createSession()

StatusCode PoolSvc::createSession	(	const std::string &	sessionName,
		int	ageLimit = -1 )

Create a new session for a given session name and age limit.

make a new session tool and add it to the list of session tools

Definition at line 879 of file PoolSvc.cxx.

{
   ToolHandle<SessionTool> session_tool = ToolHandle<SessionTool>("SessionTool/" + sessionName, this);
   ATH_CHECK(session_tool.retrieve());
   session_tool->setupFC( *m_catalog, dbAgeLimit );
   m_dbSessionVec.push_back(session_tool);
   return StatusCode::SUCCESS;
}

disconnect()

StatusCode PoolSvc::disconnect ( unsigned int contextId = IPoolSvc::kInputStream )

overridevirtual

Disconnect PersistencySvc associated with a contextId.

Parameters

contextId

[IN] poolStream to be disconnected.

Definition at line 541 of file PoolSvc.cxx.

                                                     {
   ATH_MSG_DEBUG("Disconnect request for contextId=" << contextId);
   if (contextId >= m_dbSessionVec.size()) {
      return StatusCode::SUCCESS;
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   auto& session = m_dbSessionVec[contextId];
   if( session->openMode() != Io::INVALID ) {
      if( !commit(contextId).isSuccess() ) {
         ATH_MSG_ERROR("disconnect failed to commit " << session);
         return StatusCode::FAILURE;
      }  
      if( session->disconnectAll() ) {
         ATH_MSG_DEBUG("Disconnected PersistencySvc session");
      } else {
         ATH_MSG_ERROR("disconnect failed to diconnect PersistencySvc");
         return StatusCode::FAILURE;
      }
   }
   return StatusCode::SUCCESS;
}

disconnectDb()

StatusCode PoolSvc::disconnectDb ( const std::string & connection, unsigned int contextId = IPoolSvc::kInputStream )

overridevirtual

Disconnect single Database.

Parameters

connection	[IN] connection string for Database to be disconnected.
contextId	[IN] context id of database to be disconnected.

Definition at line 563 of file PoolSvc.cxx.

                                                                                    {
   if (contextId >= m_dbSessionVec.size()) {
      return (StatusCode::SUCCESS);
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   std::unique_ptr<pool::IDatabase> dbH = getDbHandle(contextId, connection);
   if (dbH == nullptr) {
      ATH_MSG_ERROR("Failed to get Session/DatabaseHandle.");
      return(StatusCode::FAILURE);
   }
   std::map<unsigned int, unsigned int>::const_iterator maxFileIter = m_contextMaxFile.find(contextId);
   if (maxFileIter != m_contextMaxFile.end() && maxFileIter->second > 0) {
      m_guidLists[contextId].remove(Guid(dbH->fid()));
   }
   dbH->disconnect();
   return(StatusCode::SUCCESS);
}

finalize()

StatusCode PoolSvc::finalize ( )

overridevirtual

Required of all Gaudi services:

Definition at line 203 of file PoolSvc.cxx.

                             {
   clearState();
   return(::AthService::finalize());
}

getAttribute() [1/2]

StatusCode PoolSvc::getAttribute ( const std::string & optName, std::string & data, long tech, const std::string & dbName, const std::string & contName = "", unsigned int contextId = IPoolSvc::kInputStream )

overridevirtual

Get POOL attributes - db/file, container/collection.

Definition at line 607 of file PoolSvc.cxx.

                                {
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   std::unique_ptr<pool::IDatabase> dbH = getDbHandle(contextId, dbName);
   if (dbH == nullptr) {
      ATH_MSG_DEBUG("getAttribute: Failed to get Session/DatabaseHandle to get POOL property.");
      return(StatusCode::FAILURE);
   }
   if (dbH->openMode() == Io::INVALID) {
      if (m_dbSessionVec[contextId]->openMode() == Io::WRITE || m_dbSessionVec[contextId]->openMode() == Io::APPEND) {
         dbH->setTechnology(tech);
         dbH->connectForWrite();
      } else {
         dbH->connectForRead();
      }
   }
   std::ostringstream oss;
   if (contName.empty()) {
      if (data == "DbLonglong") {
         long long int attr_data;
         oss << std::dec << dbH->attributeOfType(optName, static_cast<void*>(&attr_data), typeid(long long int), "");
      } else if (data == "double") {
         double attr_data;
         oss << std::dec << dbH->attributeOfType(optName, static_cast<void*>(&attr_data), typeid(double), "");
      } else if (data == "string") {
         char* attr_data;
         oss << std::dec << dbH->attributeOfType(optName, static_cast<void*>(&attr_data), typeid(char*), "");
      } else {
         int attr_data;
         oss << std::dec << dbH->attributeOfType(optName, static_cast<void*>(&attr_data), typeid(int), "");
      }
      ATH_MSG_INFO("Database (" << dbH->pfn() << ") attribute [" << optName << "]" << ": " << oss.str());
   } else {
      std::unique_ptr<pool::IContainer> contH = getContainerHandle(dbH.get(), contName);
      if (contH == nullptr) {
         ATH_MSG_DEBUG("Failed to get ContainerHandle to get POOL property.");
         return(StatusCode::FAILURE);
      }
      if (data == "DbLonglong") {
         long long int attr_data;
         oss << std::dec << contH->attributeOfType(optName, static_cast<void*>(&attr_data), typeid(long long int), "");
      } else if (data == "double") {
         double attr_data;
         oss << std::dec << contH->attributeOfType(optName, static_cast<void*>(&attr_data), typeid(double), "");
      } else {
         int attr_data;
         oss << std::dec << contH->attributeOfType(optName, static_cast<void*>(&attr_data), typeid(int), "");
      }
      ATH_MSG_INFO("Container attribute [" << contName << "." << optName << "]: " << oss.str());
   }
   data = oss.str();
   return(StatusCode::SUCCESS);
}

getAttribute() [2/2]

StatusCode PoolSvc::getAttribute ( const std::string & optName, std::string & data, long tech, unsigned int contextId = IPoolSvc::kInputStream )

overridevirtual

Get POOL attributes - domain.

Definition at line 581 of file PoolSvc.cxx.

                                {
   if (contextId >= m_dbSessionVec.size()) {
      ATH_MSG_WARNING("getAttribute: Using default input Stream instead of id = " << contextId);
      contextId = IPoolSvc::kInputStream;
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   auto& sesH = m_dbSessionVec[contextId];
   std::ostringstream oss;
   if (data == "DbLonglong") {
      long long int attr_data;
      oss << std::dec << sesH->microSessionManager(tech).attributeOfType(optName, static_cast<void*>(&attr_data), typeid(long long int), "");
   } else if (data == "double") {
      double attr_data;
      oss << std::dec << sesH->microSessionManager(tech).attributeOfType(optName, static_cast<void*>(&attr_data), typeid(double), "");
   } else {
      int attr_data;
      oss << std::dec << sesH->microSessionManager(tech).attributeOfType(optName, static_cast<void*>(&attr_data), typeid(int), "");
   }
   data = oss.str();
   ATH_MSG_INFO("Domain attribute [" << optName << "]" << ": " << data);
   return(StatusCode::SUCCESS);
}

getContainerHandle()

std::unique_ptr< pool::IContainer > PoolSvc::getContainerHandle ( pool::IDatabase * dbH, const std::string & contName )

private

Get Container handle.

Definition at line 846 of file PoolSvc.cxx.

                                                                                                       {
   pool::IContainer* contH = nullptr;
   if (dbH == nullptr) {
      ATH_MSG_DEBUG("No DatabaseHandle to get Container.");
      return(nullptr);
   }
   if (contName.find("DataHeader") != std::string::npos) {
      contH = dbH->containerHandle(contName.substr(0, contName.find("_p")));
   } else {
      contH = dbH->containerHandle(contName);
   }
   return(std::unique_ptr<pool::IContainer>(contH));
}

getDbHandle()

std::unique_ptr< pool::IDatabase > PoolSvc::getDbHandle ( unsigned int contextId, const std::string & dbName )

private

Get Database handle.

Definition at line 818 of file PoolSvc.cxx.

                                                                                                 {
   if (contextId >= m_dbSessionVec.size()) {
      ATH_MSG_WARNING("getDbHandle: Using default input Stream instead of id = " << contextId);
      contextId = IPoolSvc::kInputStream;
   }
   auto& sesH = m_dbSessionVec[contextId];
   if (!sesH){
     ATH_MSG_ERROR("Session pointer is null.");
     return nullptr;
   }
   if (sesH->openMode() == Io::INVALID) {
      Io::IoFlag transMode = Io::READ;
      ATH_MSG_DEBUG("Start transaction, type = " << transMode);
      if (!sesH->start(transMode)) {
         ATH_MSG_WARNING("Failed to start transaction, type = " << transMode);
         return nullptr;
      }
   }
   if (dbName.starts_with("PFN:")) {
      return sesH->databaseHandle(dbName.substr(4), pool::DatabaseSpecification::PFN);
   } else if (dbName.starts_with("LFN:")) {
      return sesH->databaseHandle(dbName.substr(4), pool::DatabaseSpecification::LFN);
   } else if (dbName.starts_with("FID:")) {
      return sesH->databaseHandle(dbName.substr(4), pool::DatabaseSpecification::FID);
   }
   return sesH->databaseHandle(dbName, pool::DatabaseSpecification::PFN);
}

getInputContext()

unsigned int PoolSvc::getInputContext ( const std::string & label, unsigned int maxFile = 0 )

overridevirtual

Returns

an Id for an input context (POOL persistency service) and create it if needed.

Parameters

label	[IN] string label to name new context and allow sharing (returns existing contextId)
maxFile	[IN] maximum number of open input files.

Definition at line 301 of file PoolSvc.cxx.

                                                                                  {
   std::lock_guard<CallMutex> lock(m_pool_mut);
   if (!label.empty()) {
      std::map<std::string, unsigned int>::const_iterator contextIter = m_inputContextLabel.find(label);
      if (contextIter != m_inputContextLabel.end()) {
         if (maxFile > 0) {
            m_contextMaxFile[contextIter->second] = maxFile;
         }
         return(contextIter->second);
      }
   }
   const unsigned int id = m_dbSessionVec.size();
   if( !createSession(label, maxFile).isSuccess() ) {
      ATH_MSG_WARNING("getInputContext: Failed to create new input Stream id = " << id << ". Using default input Stream instead.");
      return(IPoolSvc::kInputStream);
   }
   m_pers_mut.push_back(new CallMutex);
   if (!connect(Io::READ, id).isSuccess()) {
      ATH_MSG_WARNING("Failed to connect Input PersistencySvc: " << id);
      return(IPoolSvc::kInputStream);
   }
   if (!label.empty()) {
      m_inputContextLabel.try_emplace(label, id);
   }
   m_contextMaxFile.try_emplace(id, maxFile);
   return(id);
}

getInputContextMap()

std::map< std::string, unsigned int > PoolSvc::getInputContextMap ( ) const

overridevirtual

Returns

copy of the map of all labelled input contexts.

Definition at line 329 of file PoolSvc.cxx.

                                                                  {
   std::lock_guard<CallMutex> lock(m_pool_mut);
   return(m_inputContextLabel);
}

getInputContextMapSize()

unsigned int PoolSvc::getInputContextMapSize ( ) const

overridevirtual

Returns

size of the map of all labelled input contexts.

Definition at line 334 of file PoolSvc.cxx.

                                                   {
   std::lock_guard<CallMutex> lock(m_pool_mut);
   return(m_inputContextLabel.size());
}

getInputFileDescriptor()

pool::FileDescriptor PoolSvc::getInputFileDescriptor ( unsigned int contextId, const std::string & connection )

overridevirtual

Returns

size of the map of all labelled input contexts.

Definition at line 339 of file PoolSvc.cxx.

                                                                                  {
   if (contextId == m_dbSessionVec.size()) {
      ATH_MSG_DEBUG("getInputFileDescriptor: On-demand creating new input Stream id = " << contextId);
      contextId = this->getInputContext("");
   }
   if (contextId >= m_dbSessionVec.size()) {
      ATH_MSG_WARNING("getInputFileDescriptor: Using default input Stream instead of id = " << contextId);
      contextId = IPoolSvc::kInputStream;
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   std::unique_ptr<pool::IDatabase> dbH = getDbHandle(contextId, connection);
   if (!dbH) {
      throw std::runtime_error("Could not retrieve a database handle to '" + connection + "'");
   }
   pool::FileDescriptor* fd = dbH->fileDescriptor();
   if (!fd) {
      throw std::runtime_error("Could not retrieve connection info from DB '" + connection + "'");
   }
   return *fd;
}

getOutputContext()

unsigned int PoolSvc::getOutputContext ( const std::string & label )

overridevirtual

Returns

an Id for an output context (POOL persistency service) and create it if needed.

Parameters

label

[IN] string label to name new context and allow sharing (returns existing contextId)

Definition at line 278 of file PoolSvc.cxx.

                                                             {
   std::lock_guard<CallMutex> lock(m_pool_mut);
   if (m_mainOutputLabel.empty()) {
      m_mainOutputLabel = label;
      m_outputContextLabel.try_emplace(label, IPoolSvc::kOutputStream);
   }
   if (label == m_mainOutputLabel || label.empty()) {
      return(IPoolSvc::kOutputStream);
   }
   std::map<std::string, unsigned int>::const_iterator contextIter = m_outputContextLabel.find(label);
   if (contextIter != m_outputContextLabel.end()) {
      return(contextIter->second);
   }
   const unsigned int id = m_dbSessionVec.size();
   if( !createSession(label).isSuccess() ) {
      ATH_MSG_WARNING("getOutputContext: Failed to create new output Stream id = " << id << ". Using default output Stream instead.");
      return(IPoolSvc::kOutputStream);
   }
   m_pers_mut.push_back(new CallMutex);
   m_outputContextLabel.try_emplace(label, id);
   return(id);
}

getToken()

Token * PoolSvc::getToken ( const std::string & connection, const std::string & collection, const unsigned long ientry )

overridevirtual

Returns

a token for a container entry.

Parameters

connection	[IN] string containing the connection/file name.
collection	[IN] string containing the persistent name of the collection.
ientry	[IN] entry number for the token to be returned

Definition at line 464 of file PoolSvc.cxx.

                                                      {
   std::lock_guard<CallMutex> lock(*m_pers_mut[IPoolSvc::kInputStream]);
   std::unique_ptr<pool::IDatabase> dbH = getDbHandle(IPoolSvc::kInputStream, connection);
   if (dbH == nullptr) {
      return(nullptr);
   }
   if (dbH->openMode() == Io::INVALID) {
      dbH->connectForRead();
   }
   std::unique_ptr<pool::IContainer> contH = getContainerHandle(dbH.get(), collection);
   if (contH == nullptr) {
      return(nullptr);
   }
   auto tokenIter = std::unique_ptr<pool::ITokenIterator>(contH->tokens());
   // the Token returned by the iterator has the refCount already increased
   return tokenIter->seek(ientry)? tokenIter->next() : nullptr;
}

initialize()

StatusCode PoolSvc::initialize ( )

overridevirtual

Required of all Gaudi services:

Definition at line 47 of file PoolSvc.cxx.

                               {
   ATH_CHECK(::AthService::initialize());
 
   // Register this service for 'I/O' events
   ServiceHandle<IIoComponentMgr> iomgr("IoComponentMgr", name());
   ATH_CHECK(iomgr.retrieve());
   ATH_CHECK(iomgr->io_register(this));
   // Register input file's names with the I/O manager, unless in SharedWrite mode, set by AthenaPoolCnvSvc
   bool allGood = true;
   for (const auto& catalog : m_readCatalog.value()) {
      if (catalog.starts_with("xmlcatalog_file:")) {
         const std::string fileName = catalog.substr(16);
         if (!iomgr->io_register(this, IIoComponentMgr::IoMode::READ, fileName, fileName).isSuccess()) {
            ATH_MSG_FATAL("could not register [" << catalog << "] for input !");
            allGood = false;
         } else {
            ATH_MSG_INFO("io_register[" << this->name() << "](" << catalog << ") [ok]");
         }
      }
   }
   if (m_writeCatalog.value().starts_with("xmlcatalog_file:")) {
      const std::string fileName = m_writeCatalog.value().substr(16);
      if (!iomgr->io_register(this, IIoComponentMgr::IoMode::WRITE, fileName, fileName).isSuccess()) {
         ATH_MSG_FATAL("could not register [" << m_writeCatalog.value() << "] for input !");
         allGood = false;
      } else {
         ATH_MSG_INFO("io_register[" << this->name() << "](" << m_writeCatalog.value() << ") [ok]");
      }
   }
   if (!allGood) {
      return(StatusCode::FAILURE);
   }
 
   MSG::Level athLvl = msg().level();
   ATH_MSG_DEBUG("OutputLevel is " << (int)athLvl);
   pool::DbPrintLvl::setLevel(athLvl);
   return(setupPersistencySvc());
}

io_finalize()

StatusCode PoolSvc::io_finalize ( )

overridevirtual

Definition at line 208 of file PoolSvc.cxx.

                                {
   ATH_MSG_INFO("I/O finalization...");
   for (size_t i = 0; i < m_dbSessionVec.size(); i++) {
      if ((m_dbSessionVec[i]->openMode() == Io::WRITE || m_dbSessionVec[i]->openMode() == Io::APPEND) &&
          !disconnect(i).isSuccess()) {
         ATH_MSG_WARNING("Cannot disconnect output Stream " << i);
      }
   }
   clearState();
   return(StatusCode::SUCCESS);
}

io_reinit()

StatusCode PoolSvc::io_reinit ( )

overridevirtual

Definition at line 87 of file PoolSvc.cxx.

                              {
   ATH_MSG_INFO("I/O reinitialization...");
   ServiceHandle<IIoComponentMgr> iomgr("IoComponentMgr", name());
   if (!iomgr.retrieve().isSuccess()) {
      ATH_MSG_FATAL("Could not retrieve IoComponentMgr !");
      return(StatusCode::FAILURE);
   }
   if (!iomgr->io_hasitem(this)) {
      ATH_MSG_FATAL("IoComponentMgr does not know about myself !");
      return(StatusCode::FAILURE);
   }
   std::vector<std::string> readcat = m_readCatalog.value();
   for (std::size_t icat = 0, imax = readcat.size(); icat < imax; icat++) {
      if (readcat[icat].starts_with("xmlcatalog_file:")) {
         std::string fileName = readcat[icat].substr(16);
         if (iomgr->io_contains(this, fileName)) {
            if (!iomgr->io_retrieve(this, fileName).isSuccess()) {
               ATH_MSG_FATAL("Could not retrieve new value for [" << fileName << "] !");
               return(StatusCode::FAILURE);
            }
            readcat[icat] = "xmlcatalog_file:" + fileName;
         }
      }
   }
   // all good... copy over.
   m_readCatalog = readcat;
   if (m_writeCatalog.value().starts_with("xmlcatalog_file:")) {
      std::string fileName = m_writeCatalog.value().substr(16);
      if (iomgr->io_contains(this, fileName)) {
         if (!iomgr->io_retrieve(this, fileName).isSuccess()) {
            ATH_MSG_FATAL("Could not retrieve new value for [" << fileName << "] !");
            return(StatusCode::FAILURE);
         }
         if (!m_shareCat) {
            m_writeCatalog.setValue("xmlcatalog_file:" + fileName);
         }
      }
   }
   return(setupPersistencySvc());
}

lookupBestPfn()

void PoolSvc::lookupBestPfn ( const std::string & dbID, std::string & pfn, std::string & type ) const

overridevirtual

Returns

void

Parameters

dbID	[IN] database ID to be translated
pfn	[OUT] string PFN of database
type	[OUT] string filetype of database

Definition at line 377 of file PoolSvc.cxx.

                                                                                        {
   FileCatalogUtils::getFirstPFN(*m_catalog, dbID, pfn, type); // FID -> best PFN
}

patchCatalog()

void PoolSvc::patchCatalog ( const std::string & pfn, pool::IDatabase & dbH ) const

private

Definition at line 456 of file PoolSvc.cxx.

                                                                         {
   std::scoped_lock lock(m_pool_mut);
   dbH.setTechnology(pool::ROOT_StorageType.type());
   std::string fid = dbH.fid();
   Gaudi::IFileCatalog* catalog_locked ATLAS_THREAD_SAFE = m_catalog.get();
   FileCatalogUtils::registerPFN(*catalog_locked, pfn, "ROOT_All", fid);
}

poolCondPath()

std::string PoolSvc::poolCondPath ( const std::string & leaf )

private

Resolve a file using ATLAS_POOLCOND_PATH.

Definition at line 860 of file PoolSvc.cxx.

                                                     {
   // look for files at $ATLAS_POOLCOND_PATH/<leaf>
   // return full filename if exists, or empty string if not
   const char* cpath = std::getenv("ATLAS_POOLCOND_PATH");
   if (cpath && strcmp(cpath, "") != 0) {
      const std::string testpath = std::string(cpath) + "/" + leaf;
 
      // Try to open file for reading. Note that a simple stat call may return
      // a wrong result if the file is residing on an auto-mounted FS (ATR-28801).
      if (FILE* fp = std::fopen(testpath.c_str(), "r")) {
         std::fclose(fp);
         return testpath;
      }
   }
   return {};
}

registerForWrite()

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

overridevirtual

Returns

a 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 220 of file PoolSvc.cxx.

                                                            {
   unsigned int contextId = IPoolSvc::kOutputStream;
   const std::string& auxString = placement->auxString();
   if (!auxString.empty()) {
      if (auxString.starts_with("[CTXT=")) {
         ::sscanf(auxString.c_str(), "[CTXT=%08X]", &contextId);
      } else if (auxString.starts_with("[CLABEL=")) {
         contextId = this->getOutputContext(auxString);
      }
      if (contextId >= m_dbSessionVec.size()) {
         ATH_MSG_WARNING("registerForWrite: Using default output Stream instead of id = " << contextId);
         contextId = IPoolSvc::kOutputStream;
      }
   }
   std::lock_guard<CallMutex> lock(*m_pers_mut[contextId]);
   Token* token = m_dbSessionVec[contextId]->registerForWrite(*placement, obj, classDesc);
   if (token == nullptr) {
      ATH_MSG_WARNING("Cannot write object: " << placement->containerName());
   }
   return(token);
}

setAttribute() [1/2]

StatusCode PoolSvc::setAttribute ( const std::string & optName, const std::string & data, long tech, const std::string & dbName, const std::string & contName = "", unsigned int contextId = IPoolSvc::kOutputStream )

overridevirtual

Set POOL attributes - db/file, container/collection.

Definition at line 691 of file PoolSvc.cxx.

                                {
   if (contextId >= m_dbSessionVec.size()) {
      ATH_MSG_WARNING("setAttribute: Using default output Stream instead of id = " << contextId);
      contextId = IPoolSvc::kOutputStream;
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   std::unique_ptr<pool::IDatabase> dbH = getDbHandle(contextId, dbName);
   if (dbH == nullptr) {
      ATH_MSG_DEBUG("Failed to get Session/DatabaseHandle to set POOL property.");
      return(StatusCode::FAILURE);
   }
   if (dbH->openMode() == Io::INVALID) {
      if (m_dbSessionVec[contextId]->openMode() == Io::WRITE || m_dbSessionVec[contextId]->openMode() == Io::APPEND) {
         dbH->setTechnology(tech);
         dbH->connectForWrite();
      } else {
         dbH->connectForRead();
      }
   }
   bool retError = false;
   std::string objName;
   bool hasTTreeName = contName.starts_with("TTree=");
   if (contName.empty() || hasTTreeName || m_dbSessionVec[contextId]->openMode() == Io::READ) {
      objName = hasTTreeName ? contName.substr(6) : contName;
      if( !isNumber(data) ) {
         const char* atttibuteValue = data.c_str();
         retError = dbH->setAttributeOfType(optName, static_cast<const void*>(&atttibuteValue), typeid(char*), objName);
      } else if( data[data.size() - 1] == 'L' ) {
         const long long int& atttibuteValue = atoll(data.c_str());
         retError = dbH->setAttributeOfType(optName, static_cast<const void*>(&atttibuteValue), typeid(long long int), objName);
      } else {
         const int& atttibuteValue = atoi(data.c_str());
         retError = dbH->setAttributeOfType(optName, static_cast<const void*>(&atttibuteValue), typeid(int), objName);
      }
      if (!retError) {
         ATH_MSG_DEBUG("Failed to set POOL property, " << optName << " to " << data);
         return(StatusCode::FAILURE);
      }
   } else {
      std::unique_ptr<pool::IContainer> contH = getContainerHandle(dbH.get(), contName);
      if (contH == nullptr) {
         ATH_MSG_DEBUG("Failed to get ContainerHandle to set POOL property.");
         return(StatusCode::FAILURE);
      }
      if (auto p = contName.find('('); p != std::string::npos) {
         objName = contName.substr(p + 1); // Get BranchName between parenthesis
         objName.erase(objName.find(')'));
      } else if (auto p = contName.find("::"); p != std::string::npos) {
         objName = contName.substr(p + 2); // Split off Tree name
      } else if (auto p = contName.find('_'); p != std::string::npos) {
         objName = contName.substr(p + 1); // Split off "POOLContainer"
         objName.erase(objName.find('/')); // Split off key
      }
      std::string::size_type off = 0;
      while ((off = objName.find_first_of("<>/")) != std::string::npos) {
         objName[off] = '_'; // Replace special chars (e.g. templates)
      }
      if (data[data.size() - 1] == 'L') {
         const long long int& atttibuteValue = atoll(data.c_str());
         retError = contH->setAttributeOfType(optName, static_cast<const void*>(&atttibuteValue), typeid(long long int), objName);
      } else {
         const int& atttibuteValue = atoi(data.c_str());
         retError = contH->setAttributeOfType(optName, static_cast<const void*>(&atttibuteValue), typeid(int), objName);
      }
      if (!retError) {
         ATH_MSG_DEBUG("Failed to set POOL container property, " << optName << " for " << contName << " : " << objName << " to " << data);
         return(StatusCode::FAILURE);
      }
   }
   return(StatusCode::SUCCESS);
}

setAttribute() [2/2]

StatusCode PoolSvc::setAttribute ( const std::string & optName, const std::string & data, long tech, unsigned int contextId = IPoolSvc::kOutputStream )

overridevirtual

Set POOL attributes - domain.

Definition at line 665 of file PoolSvc.cxx.

                                {
   if (contextId >= m_dbSessionVec.size()) {
      ATH_MSG_WARNING("setAttribute: Using default output Stream instead of id = " << contextId);
      contextId = IPoolSvc::kOutputStream;
   }
   ContextLock lock(contextId, m_pool_mut, m_pers_mut);
   auto& sesH = m_dbSessionVec[contextId];
   if (data[data.size() - 1] == 'L') {
      const long long int& atttibuteValue = atoll(data.c_str());
      if (!sesH->microSessionManager(tech).setAttributeOfType(optName, static_cast<const void*>(&atttibuteValue), typeid(long long int), "")) {
         ATH_MSG_DEBUG("Failed to set POOL property, " << optName << " to " << data);
         return(StatusCode::FAILURE);
      }
   } else {
      const int& atttibuteValue = atoi(data.c_str());
      if (!sesH->microSessionManager(tech).setAttributeOfType(optName, static_cast<const void*>(&atttibuteValue), typeid(int), "")) {
         ATH_MSG_DEBUG("Failed to set POOL property, " << optName << " to " << data);
         return(StatusCode::FAILURE);
      }
   }
   return(StatusCode::SUCCESS);
}

setObjPtr()

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

overridevirtual

Returns

void

Parameters

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

Definition at line 244 of file PoolSvc.cxx.

                                                      {
   unsigned int contextId = IPoolSvc::kInputStream;
   const std::string& auxString = token->auxString();
   bool allowAging = true;
   if (!auxString.empty()) {
      if (auxString.starts_with("[CTXT=")) {
         ::sscanf(auxString.c_str(), "[CTXT=%08X]", &contextId);
         if (contextId == m_dbSessionVec.size()) {
            ATH_MSG_DEBUG("setObjPtr: On-demand creating new input Stream id = " << contextId);
            contextId = this->getInputContext("");
         }
      } else if (auxString.starts_with("[CLABEL=")) {
         contextId = this->getInputContext(auxString);
      }
      if (contextId >= m_dbSessionVec.size()) {
         ATH_MSG_WARNING("setObjPtr: Using default input Stream instead of id = " << contextId);
         contextId = IPoolSvc::kInputStream;
         allowAging = false;
      }
   }
   ATH_MSG_VERBOSE("setObjPtr: token=" << token->toString() << ", auxString=" << auxString << ", contextID=" << contextId);
   // Get Context ID/label from Token
   std::lock_guard<CallMutex> lock(*m_pers_mut[contextId]);
   obj = m_dbSessionVec[contextId]->readObject(*token, obj);
   std::map<unsigned int, unsigned int>::const_iterator maxFileIter = m_contextMaxFile.find(contextId);
   if (allowAging && maxFileIter != m_contextMaxFile.end() && maxFileIter->second > 0) {
      m_guidLists[contextId].remove(token->dbID());
      m_guidLists[contextId].push_back(token->dbID());
      while (m_guidLists[contextId].size() > maxFileIter->second) {
         this->disconnectDb("FID:" + m_guidLists[contextId].begin()->toString(), contextId).ignore();
      }
   }
}

setShareMode()

void PoolSvc::setShareMode ( bool shareCat )

overridevirtual

Returns

void

Parameters

shareCat

[IN] bool to share the file catalog.

Definition at line 361 of file PoolSvc.cxx.

                                        {
   m_shareCat = shareCat;
}

setupPersistencySvc()

StatusCode PoolSvc::setupPersistencySvc ( )

private

Definition at line 128 of file PoolSvc.cxx.

                                        {
   clearState();
   ATH_MSG_INFO("Setting up FileCatalog and Streams");
   if (!createCatalog()) {
      ATH_MSG_FATAL("Failed to setup POOL File Catalog.");
      return(StatusCode::FAILURE);
   }
   m_catalog->init();
   // Setup a persistency services
   ATH_CHECK( createSession("ReadSession") ); // Add Read Session
   m_pers_mut.push_back(new CallMutex);
   const bool& atttibuteValue = true;
   if (!m_dbSessionVec[IPoolSvc::kInputStream]->microSessionManager(pool::ROOT_StorageType.type()).setAttributeOfType("ENABLE_THREADSAFETY", static_cast<const void*>(&atttibuteValue), typeid(bool), "")) {
      ATH_MSG_FATAL("Failed to enable thread safety in ROOT via PersistencySvc.");
      return(StatusCode::FAILURE);
   }
   m_contextMaxFile.try_emplace(IPoolSvc::kInputStream, m_dbAgeLimit.value());
   if (!connect(Io::READ, IPoolSvc::kInputStream).isSuccess()) {
      ATH_MSG_FATAL("Failed to connect Input PersistencySvc.");
      return(StatusCode::FAILURE);
   }
   ATH_CHECK( createSession("WriteSession") ); // Add Write Session
   m_pers_mut.push_back(new CallMutex);
 
   return(StatusCode::SUCCESS);
}

start()

StatusCode PoolSvc::start ( )

overridevirtual

Required of all Gaudi services:

Definition at line 155 of file PoolSvc.cxx.

                          {
   // Switiching on ROOT implicit multi threading for AthenaMT
   if (m_useROOTIMT && Gaudi::Concurrency::ConcurrencyFlags::numThreads() > 1) {
      const int& atttibuteValue = Gaudi::Concurrency::ConcurrencyFlags::numThreads() - 1;
      if (!m_dbSessionVec[IPoolSvc::kInputStream]->microSessionManager(pool::ROOT_StorageType.type()).setAttributeOfType("ENABLE_IMPLICITMT", static_cast<const void*>(&atttibuteValue), typeid(int), "")) {
         ATH_MSG_FATAL("Failed to enable implicit multithreading in ROOT via PersistencySvc.");
         return(StatusCode::FAILURE);
      }
      ATH_MSG_INFO("Enabled implicit multithreading in ROOT via PersistencySvc to: " << Gaudi::Concurrency::ConcurrencyFlags::numThreads() - 1);
   }
   return(StatusCode::SUCCESS);
}

startCatalog()

void PoolSvc::startCatalog ( )

overridevirtual

Returns

void

Definition at line 365 of file PoolSvc.cxx.

                           {
   if (m_catalog.isValid()) {
      m_catalog->init();
   }
}

stop()

StatusCode PoolSvc::stop ( )

overridevirtual

Definition at line 168 of file PoolSvc.cxx.

                         {
   ATH_MSG_VERBOSE("stop()");
   bool retError = false;
   for (unsigned int contextId = 0, imax = m_dbSessionVec.size(); contextId < imax; contextId++) {
      if (!disconnect(contextId).isSuccess()) {
         ATH_MSG_FATAL("Cannot disconnect Stream: " << contextId);
         retError = true;
      }
   }
   return(retError ? StatusCode::FAILURE : StatusCode::SUCCESS);
}

Member Data Documentation

ATLAS_THREAD_SAFE

std::map<unsigned int, std::list<Guid> > m_guidLists PoolSvc::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 234 of file PoolSvc.h.

m_attemptCatalogPatch

Gaudi::Property<bool> PoolSvc::m_attemptCatalogPatch {this,"AttemptCatalogPatch",true}

private

AttemptCatalogPatch, option to create catalog: default = false.

Definition at line 251 of file PoolSvc.h.

{this,"AttemptCatalogPatch",true};

m_catalog

SmartIF<Gaudi::IFileCatalog> PoolSvc::m_catalog

private

Definition at line 225 of file PoolSvc.h.

m_catalogMgr

SmartIF<Gaudi::IFileCatalogMgr> PoolSvc::m_catalogMgr

private

Definition at line 224 of file PoolSvc.h.

m_contextMaxFile

std::map<unsigned int, unsigned int> PoolSvc::m_contextMaxFile

private

Definition at line 232 of file PoolSvc.h.

m_dbAgeLimit

Gaudi::Property<int> PoolSvc::m_dbAgeLimit {this,"MaxFilesOpen",0}

private

MaxFilesOpen, option to have PoolSvc limit the number of open Input Files: default = 0 (No files are closed automatically).

Definition at line 239 of file PoolSvc.h.

{this,"MaxFilesOpen",0};

m_dbSessionVec

std::vector<ToolHandle<SessionTool> > PoolSvc::m_dbSessionVec

private

Definition at line 226 of file PoolSvc.h.

m_inputContextLabel

std::map<std::string, unsigned int> PoolSvc::m_inputContextLabel

private

Definition at line 229 of file PoolSvc.h.

m_mainOutputLabel

std::string PoolSvc::m_mainOutputLabel {}

private

Definition at line 231 of file PoolSvc.h.

{};

m_outputContextLabel

std::map<std::string, unsigned int> PoolSvc::m_outputContextLabel

private

Definition at line 230 of file PoolSvc.h.

m_pers_mut

std::vector<CallMutex*> PoolSvc::m_pers_mut

private

Definition at line 228 of file PoolSvc.h.

m_pool_mut

CallMutex PoolSvc::m_pool_mut

mutableprivate

Definition at line 221 of file PoolSvc.h.

m_readCatalog

Gaudi::Property<std::vector<std::string> > PoolSvc::m_readCatalog {this,"ReadCatalog",{},"List of catalog files to read from","OrderedSet<std::string>"}

private

ReadCatalog, the list of additional POOL input file catalogs to consult: default = empty vector.

Definition at line 244 of file PoolSvc.h.

{this,"ReadCatalog",{},"List of catalog files to read from","OrderedSet<std::string>"};

m_shareCat

bool PoolSvc::m_shareCat {false}

private

Definition at line 223 of file PoolSvc.h.

{false};

m_useROOTIMT

Gaudi::Property<bool> PoolSvc::m_useROOTIMT {this,"UseROOTImplicitMT",true}

private

Use ROOT Implicit MultiThreading, default = true.

Definition at line 246 of file PoolSvc.h.

{this,"UseROOTImplicitMT",true};

m_useROOTMaxTree

Gaudi::Property<bool> PoolSvc::m_useROOTMaxTree {this,"UseROOTIncreaseVMaxTree",false}

private

Increase virtual TTree size to avoid backreads in multithreading, default = false.

Definition at line 248 of file PoolSvc.h.

{this,"UseROOTIncreaseVMaxTree",false};

m_writeCatalog

Gaudi::Property<std::string> PoolSvc::m_writeCatalog {this,"WriteCatalog","xmlcatalog_file:PoolFileCatalog.xml"}

private

WriteCatalog, the file catalog to be used to register output files (also default input catalog): default = "" (use POOL default).

Definition at line 242 of file PoolSvc.h.

{this,"WriteCatalog","xmlcatalog_file:PoolFileCatalog.xml"};

---

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

• PoolSvc.h
• PoolSvc.cxx