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. More...
virtual StatusCode	io_reinit () override
virtual StatusCode	finalize () override
	Required of all Gaudi Services. More...
virtual StatusCode	io_finalize () override
virtual StatusCode	stop () override final
virtual StatusCode	createObj (IOpaqueAddress *pAddress, DataObject *&refpObject) override
	Implementation of IConversionSvc: Create the transient representation of an object from persistent state. More...
virtual StatusCode	createRep (DataObject *pObject, IOpaqueAddress *&refpAddress) override
	Implementation of IConversionSvc: Convert the transient object to the requested representation. More...
virtual StatusCode	fillRepRefs (IOpaqueAddress *pAddress, DataObject *pObject) override
	Implementation of IConversionSvc: Resolve the references of the converted object. More...
virtual StatusCode	connectOutput (const std::string &outputConnectionSpec, const std::string &openMode) override
	Implementation of IConversionSvc: Connect to the output connection specification with open mode. More...
virtual StatusCode	connectOutput (const std::string &outputConnectionSpec) override
	Implementation of IConversionSvc: Connect to the output connection specification with open mode. More...
virtual StatusCode	commitOutput (const std::string &outputConnectionSpec, bool doCommit) override
	Implementation of IConversionSvc: Commit pending output. More...
virtual StatusCode	disconnectOutput (const std::string &outputConnectionSpec) override
	Disconnect to the output connection. More...
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. More...
virtual StatusCode	createAddress (long svcType, const CLID &clid, const std::string &refAddress, IOpaqueAddress *&refpAddress) override
	Create address from string form. More...
virtual StatusCode	convertAddress (const IOpaqueAddress *pAddress, std::string &refAddress) override
	Convert address to string form. More...
virtual StatusCode	decodeOutputSpec (std::string &connectionSpec, int &outputTech) const override
	Extract/deduce the DB technology from the connection string/file specification. More...
virtual StatusCode	registerCleanUp (IAthenaPoolCleanUp *cnv) override
	Implement registerCleanUp to register a IAthenaPoolCleanUp to be called during cleanUp. More...
virtual StatusCode	cleanUp (const std::string &connection) override
	Implement cleanUp to call all registered IAthenaPoolCleanUp cleanUp() function. More...
virtual StatusCode	setInputAttributes (const std::string &fileName) override
	Set the input file attributes, if any are requested from jobOpts. More...
virtual StatusCode	makeServer (int num) override
	Make this a server. More...
virtual StatusCode	makeClient (int num) override
	Make this a client. More...
virtual StatusCode	readData () override
	Read the next data object. More...
virtual StatusCode	commitCatalog () override
	Commit Catalog. More...
StatusCode	abortSharedWrClients (int client_n)
	Send abort to SharedWriter clients if the server quits on error. More...
virtual void	handle (const Incident &incident) override
	Implementation of IIncidentListener: Handle for EndEvent incidence. More...
void	flushDataHeaderForms (const std::string &streamName="*")
	Tell DataHeaderCnv to write out all DataHeaderForms for a given streamName (default is all) More...
	AthenaPoolCnvSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Service Constructor. More...
virtual	~AthenaPoolCnvSvc ()=default
	Destructor. More...

Private Member Functions
void	extractPoolAttributes (const StringArrayProperty &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. More...
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. More...
unsigned	outputContextId (const std::string &outputConnection)

Private Attributes
pool::DbType	m_dbType
	decoded storage tech requested in "StorageTechnology" property More...
std::string	m_lastInputFileName
ServiceHandle< IPoolSvc >	m_poolSvc {this,"PoolSvc","PoolSvc"}
ServiceHandle< IClassIDSvc >	m_clidSvc {this,"ClassIDSvc","ClassIDSvc"}
ServiceHandle< IAthenaSerializeSvc >	m_serializeSvc {this,"AthenaRootSerializeSvc","AthenaRootSerializeSvc"}
ToolHandle< IAthenaIPCTool >	m_inputStreamingTool {this,"InputStreamingTool",{}}
ToolHandle< IAthenaIPCTool >	m_outputStreamingTool {this,"OutputStreamingTool",{}}
bool	m_streamServerActive =false
int	m_metadataClient =0
PMonUtils::BasicStopWatchResultMap_t	m_chronoMap {}
	Map that holds chrono information. More...
BooleanProperty	m_useDetailChronoStat {this,"UseDetailChronoStat",false}
	UseDetailChronoStat, enable detailed output for time and size statistics for AthenaPOOL: default = false. More...
StringProperty	m_storageTechProp {this,"StorageTechnology", "ROOTTREEINDEX"}
	Default Storage Tech for containers (ROOTTREE, ROOTTREEINDEX, ROOTRNTUPLE) More...
StringProperty	m_containerPrefixProp {this,"PoolContainerPrefix","Default"}
	POOL Container name prefix - will be part of or whole TTree/RNTuple name 'Default' takes the prefix from APRDefaults according to StorageTech. More...
StringProperty	m_containerNameHintProp {this,"TopLevelContainerName",""}
	TopLevelContainerName, naming hint policy for top level POOL container: default = "<type>". More...
StringProperty	m_branchNameHintProp {this,"SubLevelBranchName", "<type>/<key>"}
	SubLevelBranchName, naming hint policy for POOL branching: ("" = no branching) More...
StringArrayProperty	m_poolAttr {this,"PoolAttributes",{},"Pool Attributes","OrderedSet<std::string>"}
	Output PoolAttributes, vector with names and values of technology specific attributes for POOL. More...
std::vector< std::vector< std::string > >	m_domainAttr
std::vector< std::vector< std::string > >	m_databaseAttr
std::vector< std::vector< std::string > >	m_containerAttr
std::vector< unsigned int >	m_contextAttr
std::map< std::string, int >	m_fileCommitCounter
std::map< std::string, int >	m_fileFlushSetting
StringArrayProperty	m_inputPoolAttr {this,"InputPoolAttributes",{}}
	Input PoolAttributes, vector with names and values of technology specific attributes for POOL. More...
std::vector< std::vector< std::string > >	m_inputAttr
StringArrayProperty	m_inputPoolAttrPerEvent {this,"PrintInputAttrPerEvt",{}}
	Print input PoolAttributes per event, vector with names of technology specific attributes for POOL to be printed each event. More...
std::vector< std::vector< std::string > >	m_inputAttrPerEvent
StringArrayProperty	m_maxFileSizes {this,"MaxFileSizes",{}}
	MaxFileSizes, vector with maximum file sizes for Athena POOL output files. More...
long long	m_domainMaxFileSize =std::numeric_limits<long long>::max()
std::map< std::string, long long >	m_databaseMaxFileSize
BooleanProperty	m_persSvcPerOutput {this,"PersSvcPerOutput",true}
	PersSvcPerOutput, boolean property to use multiple persistency services, one per output stream. More...
StringProperty	m_persSvcPerInputType {this,"PersSvcPerInputType",""}
	PersSvcPerInputType, string property, tree name to use multiple persistency services, one per input type. More...
std::mutex	m_mutex
StringProperty	m_metadataContainerProp {this,"OutputMetadataContainer","MetaData"}
	For SharedWriter: To use MetadataSvc to merge data placed in a certain container. More...
StringArrayProperty	m_metadataContainersAug {this, "OutputMetadataContainers", {}, "Metadata containers used for augmentations"}
IntegerProperty	m_makeStreamingToolClient {this,"MakeStreamingToolClient",0}
	Make this instance a Streaming Client during first connect/write automatically. More...
IntegerProperty	m_streamingTechnology {this,"StreamingTechnology",-1}
	Use Streaming for selected technologies only. More...
BooleanProperty	m_parallelCompression {this,"ParallelCompression",true}
	Use Athena Object sharing for metadata only, event data is collected and send via ROOT TMemFile. More...
StringProperty	m_streamPortString {this,"StreamPortString","?pmerge=localhost:0"}
	Extension to use ROOT TMemFile for event data, "?pmerge=<host>:<port>". More...
IntegerProperty	m_numberEventsPerWrite {this,"NumberEventsPerWrite",-1}
	When using TMemFile call Write on number of Events, respecting CollectionTree auto_flush. More...
BooleanProperty	m_oneDataHeaderForm { this, "OneDataHeaderForm", false }
	If true, use only one DataHeaderForm per Stream. More...
IntegerProperty	m_DHFormCacheSize { this, "maxDHFormCacheSize", 100 }
	Property for DataHeaderCnv input DHForm cache size. More...
BooleanProperty	m_DHFilterAliases { this, "doFilterDHAliases", true }
	Flag to control SG alias filtering when writing out DataHeader (see DataHeaderCnv_p6) More...

Friends
class	SvcFactory< AthenaPoolCnvSvc >

Detailed Description

This class provides the interface between Athena and PoolSvc.

Definition at line 41 of file AthenaPoolCnvSvc.h.

Constructor & Destructor Documentation

AthenaPoolCnvSvc()

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

Standard Service Constructor.

Definition at line 1254 of file AthenaPoolCnvSvc.cxx.

                                                                                  :
    base_class(name, pSvcLocator, POOL_StorageType)
{
}

~AthenaPoolCnvSvc()

virtual AthenaPoolCnvSvc::~AthenaPoolCnvSvc ( )

virtualdefault

Destructor.

Member Function Documentation

abortSharedWrClients()

StatusCode AthenaPoolCnvSvc::abortSharedWrClients

(

int

client_n

)

Send abort to SharedWriter clients if the server quits on error.

Parameters

client_n

[IN] number of the current client, -1 if no current

Definition at line 1223 of file AthenaPoolCnvSvc.cxx.

{
   ATH_MSG_ERROR("Sending ABORT to clients");
   // the master process will kill this process once workers abort
   // but it could be a time-limited loop
   StatusCode sc = StatusCode::SUCCESS;
   while (sc.isSuccess()) {
      if (client_n >= 0) {
         sc = m_outputStreamingTool->lockObject("ABORT", client_n);
      }
      const char* dummy;
      sc = m_outputStreamingTool->clearObject(&dummy, client_n);
      while (sc.isRecoverable()) {
         sc = m_outputStreamingTool->clearObject(&dummy, client_n);
      }
   }
   return StatusCode::FAILURE;
}

cleanUp()

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

overridevirtual

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

Definition at line 1055 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);
}

commitCatalog()

StatusCode AthenaPoolCnvSvc::commitCatalog ( )

overridevirtual

Commit Catalog.

Definition at line 1214 of file AthenaPoolCnvSvc.cxx.

                                           {
   pool::IFileCatalog* catalog ATLAS_THREAD_SAFE =  // This is on the SharedWriter, after mother process finishes events
       const_cast<pool::IFileCatalog*>(m_poolSvc->catalog());
   catalog->commit();
   catalog->start();
   return(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 399 of file AthenaPoolCnvSvc.cxx.

                                                                                              {
   // This is called after all DataObjects are converted.
   std::string outputConnection = outputConnectionSpec.substr(0, outputConnectionSpec.find('['));
   if (!m_outputStreamingTool.empty() && m_outputStreamingTool->isClient()
       && (!m_parallelCompression || outputConnectionSpec.find("[PoolContainerPrefix=" + m_metadataContainerProp.value() + "]") != std::string::npos)) {
      m_outputStreamingTool->lockObject("wait").ignore();
      if (!this->cleanUp(outputConnection).isSuccess()) {
         ATH_MSG_ERROR("commitOutput FAILED to cleanup converters.");
         return(StatusCode::FAILURE);
      }
      return(StatusCode::SUCCESS);
   }
   if (!m_outputStreamingTool.empty() && !m_outputStreamingTool->isClient() && !m_outputStreamingTool->isServer()) {
      ATH_MSG_DEBUG("commitOutput SKIPPED for uninitialized server.");
      return(StatusCode::SUCCESS);
   }
   std::map<void*, RootType> commitCache;
   std::string fileName;
   if (!m_outputStreamingTool.empty() && !m_outputStreamingTool->isClient() && m_outputStreamingTool->isServer() && m_streamServerActive) {
      // Clear object to get Placements for all objects in a Stream
      const char* placementStr = nullptr;
      int num = -1;
      StatusCode sc = m_outputStreamingTool->clearObject(&placementStr, num);
      if (sc.isSuccess() && placementStr != nullptr && strlen(placementStr) > 6 && num > 0) {
         const char * matchedChars = strstr(placementStr, "[FILE=");
         if (not matchedChars){
           ATH_MSG_ERROR("No matching filename in  " << placementStr);
           return abortSharedWrClients(num);
         }
         fileName = matchedChars;
         fileName = fileName.substr(6, fileName.find(']') - 6);
         if (!this->connectOutput(fileName).isSuccess()) {
            ATH_MSG_ERROR("Failed to connectOutput for " << fileName);
            return abortSharedWrClients(num);
         }
         IConverter* DHcnv = converter(ClassID_traits<DataHeader>::ID());
         bool dataHeaderSeen = false;
         std::string dataHeaderID;
         while (num > 0) {
            std::string objName = "ALL";
            if (m_useDetailChronoStat.value()) {
               std::string objName(placementStr); //FIXME, better descriptor
            }
            // StopWatch listens from here until the end of this current scope
            {
               PMonUtils::BasicStopWatch stopWatch("cRep_" + objName, m_chronoMap);
               std::string tokenStr = placementStr;
               std::string contName = strstr(placementStr, "[CONT=");
               tokenStr.erase(tokenStr.find("[CONT=")); //throws if [CONT= not found
               tokenStr.append(contName, contName.find(']') + 1);
               contName = contName.substr(6, contName.find(']') - 6);
               std::string className = strstr(placementStr, "[PNAME=");
               className = className.substr(7, className.find(']') - 7);
               RootType classDesc = RootType::ByNameNoQuiet(className);
               void* obj = nullptr;
               std::ostringstream oss2;
               oss2 << std::dec << num;
               std::string::size_type len = m_metadataContainerProp.value().size();
               bool foundContainer = false;
               std::size_t pPos = contName.find('(');
               if (contName.compare(0, pPos, m_metadataContainerProp.value()) == 0) {
                  foundContainer = true;
               }
               else {
                  for (const auto& item: m_metadataContainersAug.value()) {
                     if (contName.compare(0, pPos, item) == 0){
                        foundContainer = true;
                        len = item.size();
                        break;
                     }
                  }
               }
               if (len > 0 && foundContainer && contName[len] == '(' ) {
                  ServiceHandle<IIncidentSvc> incSvc("IncidentSvc", name());
                  // For Metadata, before moving to next client, fire file incidents
                  if (m_metadataClient != num) {
                     if (m_metadataClient != 0) {
                        std::ostringstream oss1;
                        oss1 << std::dec << m_metadataClient;
                        std::string memName = "SHM[NUM=" + oss1.str() + "]";
                        FileIncident beginInputIncident(name(), "BeginInputFile", memName);
                        incSvc->fireIncident(beginInputIncident);
                        FileIncident endInputIncident(name(), "EndInputFile", memName);
                        incSvc->fireIncident(endInputIncident);
                     }
                     m_metadataClient = num;
                  }
                  // Retrieve MetaDataSvc
                  ServiceHandle<IAthMetaDataSvc> metadataSvc("MetaDataSvc", name());
                  ATH_CHECK(metadataSvc.retrieve());
                  sc = metadataSvc->shmProxy(std::string(placementStr) + "[NUM=" + oss2.str() + "]");
                  if (sc.isRecoverable()) {
                     ATH_MSG_WARNING("MetaDataSvc::shmProxy() no proxy added.");
                  } else if (sc.isFailure()) {
                     ATH_MSG_FATAL("MetaDataSvc::shmProxy() failed!");
                     return abortSharedWrClients(num);
                  }
               } else {
                  Token readToken;
                  readToken.setOid(Token::OID_t(num, 0));
                  readToken.setAuxString("[PNAME=" + className + "]");
                  this->setObjPtr(obj, &readToken); // Pull/read Object out of shared memory
                  if (len == 0 || contName.compare(0, len, m_metadataContainerProp.value()) != 0) {
                     // Write object
                     if( m_oneDataHeaderForm.value() ) {
                        auto placementWithSwn = [&] { return std::format("{}[SWN={}]",  placementStr, num); };
                        if( className == "DataHeaderForm_p6" ) {
                           // Pass DHForms to the converter for later writing in the correct order - do not write it now
                           GenericAddress address(POOL_StorageType, ClassID_traits<DataHeader>::ID(),
                                                  "", placementWithSwn());
                           DHcnv->updateRepRefs(&address, static_cast<DataObject*>(obj)).ignore();
                           tokenStr = "";
                        } else {
                           Placement placement;
                           placement.fromString(placementStr);
                           std::unique_ptr<Token> token(registerForWrite(&placement, obj, classDesc));
                           if (token == nullptr) {
                              ATH_MSG_ERROR("Failed to write Data for: " << className);
                              return abortSharedWrClients(num);
                           }
                           tokenStr = token->toString();
                        }
                        if( className == "DataHeader_p6" ) {
                           // Found DataHeader - call the converter to update DHForm Ref
                           GenericAddress address(POOL_StorageType, ClassID_traits<DataHeader>::ID(),
                                                  tokenStr, placementWithSwn());
                           if (!DHcnv->updateRep(&address, static_cast<DataObject*>(obj)).isSuccess()) {
                              ATH_MSG_ERROR("Failed updateRep for obj = " << tokenStr);
                              return abortSharedWrClients(num);
                           }
                        } else 
                        if (className != "Token" && className != "DataHeaderForm_p6" && !classDesc.IsFundamental()) {
                           commitCache.insert(std::pair<void*, RootType>(obj, classDesc));
                        }
                        placementStr = nullptr;
                     } else { 
 
                        // Multiple shared DataHeaderForms
                        Placement placement;
                        placement.fromString(placementStr); placementStr = nullptr;
                        std::unique_ptr<Token> token(registerForWrite(&placement, obj, classDesc));
                        if (token == nullptr) {
                           ATH_MSG_ERROR("Failed to write Data for: " << className);
                           return abortSharedWrClients(num);
                        }
                        tokenStr = token->toString();
                        if (className == "DataHeader_p6") {
                           // Found DataHeader
                           GenericAddress address(POOL_StorageType, ClassID_traits<DataHeader>::ID(),
                                                  tokenStr, placement.auxString());
                           // call DH converter to add the ref to DHForm (stored earlier) and to itself
                           if (!DHcnv->updateRep(&address, static_cast<DataObject*>(obj)).isSuccess()) {
                              ATH_MSG_ERROR("Failed updateRep for obj = " << tokenStr);
                              return abortSharedWrClients(num);
                           }
                           dataHeaderSeen = true;
                           // This dataHeaderID is used in DataHeaderCnv to index the DataHeaderForm cache.
                           // It must be unique per worker per stream so that we have a correct DataHeader(Form) association.
                           // This is achieved by building it as "CONTID/WORKERID/DBID".
                           // CONTID, e.g., POOLContainer(DataHeader), allows us to distinguish data and metadata headers,
                           // WORKERID allows us to distinguish AthenaMP workers,
                           // and DBID allows us to distinguish streams.
                           dataHeaderID = std::format("{}/{}/{}", token->contID(), oss2.str(), token->dbID().toString());
                        } else if (dataHeaderSeen) {
                           dataHeaderSeen = false;
                           // next object after DataHeader - may be a DataHeaderForm
                           // in any case we need to call the DH converter to update the DHForm Ref
                           if (className == "DataHeaderForm_p6") {
                              // Tell DataHeaderCnv that it should use a new DHForm
                              GenericAddress address(POOL_StorageType, ClassID_traits<DataHeader>::ID(),
                                                     tokenStr, dataHeaderID);
                              if (!DHcnv->updateRepRefs(&address, static_cast<DataObject*>(obj)).isSuccess()) {
                                 ATH_MSG_ERROR("Failed updateRepRefs for obj = " << tokenStr);
                                 return abortSharedWrClients(num);
                              }
                           } else {
                              // Tell DataHeaderCnv that it should use the old DHForm
                              GenericAddress address(0, 0, "", dataHeaderID);
                              if (!DHcnv->updateRepRefs(&address, nullptr).isSuccess()) {
                                 ATH_MSG_ERROR("Failed updateRepRefs for DataHeader");
                                 return abortSharedWrClients(num);
                              }
                           }
                        }
                        if (className != "Token" && className != "DataHeaderForm_p6" && !classDesc.IsFundamental()) {
                           commitCache.insert(std::pair<void*, RootType>(obj, classDesc));
                        }
                     }
                  }
               }
               // Send Token back to Client
               sc = m_outputStreamingTool->lockObject(tokenStr.c_str(), num);
               while (sc.isRecoverable()) {
                  sc = m_outputStreamingTool->lockObject(tokenStr.c_str(), num);
               }
               if (!sc.isSuccess()) {
                  ATH_MSG_ERROR("Failed to lock Data for " << tokenStr);
                  return abortSharedWrClients(-1);
               }
            }
            sc = m_outputStreamingTool->clearObject(&placementStr, num);
            while (sc.isRecoverable()) {
               sc = m_outputStreamingTool->clearObject(&placementStr, num);
            }
            if (sc.isFailure()) {
               // no more clients, break the loop and exit
               num = -1;
            }
         }
         if (dataHeaderSeen) {
            // DataHeader was the last object, need to tell the converter there is no DHForm coming
            GenericAddress address(0, 0, "", dataHeaderID);
            if (!DHcnv->updateRepRefs(&address, nullptr).isSuccess()) {
               ATH_MSG_ERROR("Failed updateRepRefs for DataHeader");
               return abortSharedWrClients(-1);
            }
         }
         placementStr = nullptr;
      } else if (sc.isSuccess() && placementStr != nullptr && strncmp(placementStr, "stop", 4) == 0) {
         return(StatusCode::RECOVERABLE);
      } else if (sc.isRecoverable() || num == -1) {
         return(StatusCode::RECOVERABLE);
      }
      if (sc.isFailure() || fileName.empty()) {
         ServiceHandle<IIncidentSvc> incSvc("IncidentSvc", name());
         std::ostringstream oss1;
         oss1 << std::dec << m_metadataClient;
         std::string memName = "SHM[NUM=" + oss1.str() + "]";
         FileIncident beginInputIncident(name(), "BeginInputFile", memName);
         incSvc->fireIncident(beginInputIncident);
         FileIncident endInputIncident(name(), "EndInputFile", memName);
         incSvc->fireIncident(endInputIncident);
         if (sc.isFailure()) {
            ATH_MSG_INFO("All SharedWriter clients stopped - exiting");
         } else {
            ATH_MSG_INFO("Failed to get Data for client: " << num);
         }
         return(StatusCode::FAILURE);
      }
   }
   if (m_parallelCompression && !fileName.empty()) {
      ATH_MSG_DEBUG("commitOutput SKIPPED for metadata-only server: " << outputConnectionSpec);
      return(StatusCode::SUCCESS);
   }
   // 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);
   if (outputConnection.empty()) {
      outputConnection = fileName;
   }
   // Extract the technology
   int tech = m_dbType.type();
   if (!decodeOutputSpec(outputConnection, tech).isSuccess()) {
      ATH_MSG_ERROR("connectOutput FAILED extract file name and technology.");
      return(StatusCode::FAILURE);
   }
   const std::string oldOutputConnection = outputConnection;
   if (!m_outputStreamingTool.empty() && m_outputStreamingTool->isClient() && m_parallelCompression) {
      m_fileCommitCounter[outputConnection] = m_fileCommitCounter[outputConnection] + 1;
      if (m_fileFlushSetting[outputConnection] > 0 && m_fileCommitCounter[outputConnection] % m_fileFlushSetting[outputConnection] == 0) {
         doCommit = true;
         ATH_MSG_DEBUG("commitOutput sending data.");
      }
      outputConnection += m_streamPortString.value();
   }
   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(oldOutputConnection).isSuccess()) {
      ATH_MSG_ERROR("commitOutput FAILED to cleanup converters.");
      return(StatusCode::FAILURE);
   }
   for (std::map<void*, RootType>::iterator iter = commitCache.begin(), last = commitCache.end(); iter != last; ++iter) {
      iter->second.Destruct(iter->first);
   }
   // Check FileSize
   long long int currentFileSize = m_poolSvc->getFileSize(outputConnection, m_dbType.type(), contextId);
   if (m_databaseMaxFileSize.find(outputConnection) != m_databaseMaxFileSize.end()) {
      if (currentFileSize > m_databaseMaxFileSize[outputConnection]) {
         ATH_MSG_WARNING("FileSize > " << m_databaseMaxFileSize[outputConnection] << " for " << outputConnection);
         return(StatusCode::RECOVERABLE);
      }
   } else if (currentFileSize > m_domainMaxFileSize) {
      ATH_MSG_WARNING("FileSize > " << m_domainMaxFileSize <<  " for " << outputConnection);
      return(StatusCode::RECOVERABLE);
   }
   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 303 of file AthenaPoolCnvSvc.cxx.

                                                                                {
// This is called before DataObjects are being converted.
   std::string outputConnection = outputConnectionSpec.substr(0, outputConnectionSpec.find('['));
   // Extract the technology
   int tech = m_dbType.type();
   if (!decodeOutputSpec(outputConnection, tech).isSuccess()) {
      ATH_MSG_ERROR("connectOutput FAILED extract file name and technology.");
      return(StatusCode::FAILURE);
   }
   if (m_makeStreamingToolClient.value() > 0 && !m_outputStreamingTool.empty() && !m_outputStreamingTool->isServer() && !m_outputStreamingTool->isClient()) {
      if (!makeClient(m_makeStreamingToolClient.value()).isSuccess()) {
         ATH_MSG_ERROR("Could not make AthenaPoolCnvSvc a Share Client");
         return(StatusCode::FAILURE);
      }
   }
   if (!m_outputStreamingTool.empty() && m_outputStreamingTool->isClient()
       && (!m_parallelCompression || outputConnectionSpec.find("[PoolContainerPrefix=" + m_metadataContainerProp.value() + "]") != std::string::npos)) {
      return(StatusCode::SUCCESS);
   }
   if (!m_outputStreamingTool.empty() && !m_outputStreamingTool->isClient()) {
      if (m_parallelCompression && outputConnectionSpec.find("[PoolContainerPrefix=" + m_metadataContainerProp.value() + "]") == std::string::npos) {
         ATH_MSG_DEBUG("connectOutput SKIPPED for metadata-only server: " << outputConnectionSpec);
         return(StatusCode::SUCCESS);
      }
      if (!m_parallelCompression && (!m_outputStreamingTool->isServer() || !m_streamServerActive)) {
         ATH_MSG_DEBUG("connectOutput SKIPPED for expired server.");
         return(StatusCode::SUCCESS);
      }
   }
 
   if (!m_outputStreamingTool.empty() && m_outputStreamingTool->isClient() && m_parallelCompression) {
      outputConnection +=  m_streamPortString.value();
   }
   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 (std::find(m_contextAttr.begin(), m_contextAttr.end(), contextId) == m_contextAttr.end()) {
      std::size_t merge = outputConnection.find(m_streamPortString.value()); // Used to remove trailing TMemFile
      int flush = m_numberEventsPerWrite.value();
      m_contextAttr.push_back(contextId);
      // Setting default 'TREE_MAX_SIZE' for ROOT to 1024 GB to avoid file chains.
      std::vector<std::string> maxFileSize;
      maxFileSize.push_back("TREE_MAX_SIZE");
      maxFileSize.push_back("1099511627776L");
      m_domainAttr.emplace_back(std::move(maxFileSize));
      // Extracting OUTPUT POOL ItechnologySpecificAttributes for Domain, Database and Container.
      extractPoolAttributes(m_poolAttr, &m_containerAttr, &m_databaseAttr, &m_domainAttr);
      for (std::vector<std::vector<std::string> >::iterator iter = m_databaseAttr.begin(), last = m_databaseAttr.end();
                      iter != last; ++iter) {
         const std::string& opt = (*iter)[0];
         std::string& data = (*iter)[1];
         const std::string& file = (*iter)[2];
         const std::string& cont = (*iter)[3];
         std::size_t equal = cont.find('='); // Used to remove leading "TTree="
         if (equal == std::string::npos) equal = 0;
         else equal++;
         std::size_t colon = m_containerPrefixProp.value().find(':');
         if (colon == std::string::npos) colon = 0; // Used to remove leading technology
         else colon++;
         const auto& strProp = m_containerPrefixProp.value();
         if (merge != std::string::npos && opt == "TREE_AUTO_FLUSH" && 0 == outputConnection.compare(0, merge, file) && cont.compare(equal, std::string::npos, strProp, colon) == 0 && data != "int" && data != "DbLonglong" && data != "double" && data != "string") {
            flush = atoi(data.c_str());
            if (flush < 0 && m_numberEventsPerWrite.value() > 0) {
               flush = m_numberEventsPerWrite.value();
               std::ostringstream eventAutoFlush;
               eventAutoFlush << flush;
               data = eventAutoFlush.str();
            } else if (flush > 0 && flush < m_numberEventsPerWrite.value()) {
               flush = flush * (int((m_numberEventsPerWrite.value()) / flush - 0.5) + 1);
            }
         }
      }
      if (merge != std::string::npos) {
         ATH_MSG_INFO("connectOutput setting auto write for: " << outputConnection << " to " << flush << " events");
         m_fileFlushSetting[outputConnection.substr(0, merge)] = flush;
      }
   }
   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 298 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 1015 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 1003 of file AthenaPoolCnvSvc.cxx.

                                      {
   if (svcType != POOL_StorageType) {
      ATH_MSG_ERROR("createAddress: svcType != POOL_StorageType " << svcType << " " << POOL_StorageType);
      return(StatusCode::FAILURE);
   }
   refpAddress = new GenericAddress(POOL_StorageType, 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 945 of file AthenaPoolCnvSvc.cxx.

                                      {
   if (svcType != POOL_StorageType) {
      ATH_MSG_ERROR("createAddress: svcType != POOL_StorageType " << svcType << " " << POOL_StorageType);
      return(StatusCode::FAILURE);
   }
   if (m_makeStreamingToolClient.value() > 0 && !m_inputStreamingTool.empty() && !m_inputStreamingTool->isServer() && !m_inputStreamingTool->isClient()) {
      if (!makeClient(-m_makeStreamingToolClient.value()).isSuccess()) {
         ATH_MSG_ERROR("Could not make AthenaPoolCnvSvc a Share Client");
         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 if (!m_inputStreamingTool.empty() && m_inputStreamingTool->isClient()) {
      Token addressToken;
      addressToken.setDb(par[0].substr(4));
      addressToken.setCont(par[1]);
      addressToken.setOid(Token::OID_t(ip[0], ip[1]));
      if (!m_inputStreamingTool->lockObject(addressToken.toString().c_str()).isSuccess()) {
         ATH_MSG_WARNING("Failed to lock Address Token: " << addressToken.toString());
         return(StatusCode::FAILURE);
      }
      void* buffer = nullptr;
      std::size_t nbytes = 0;
      StatusCode sc = m_inputStreamingTool->getObject(&buffer, nbytes);
      while (sc.isRecoverable()) {
         // sleep
         sc = m_inputStreamingTool->getObject(&buffer, nbytes);
      }
      if (!sc.isSuccess()) {
         ATH_MSG_WARNING("Failed to get Address Token: " << addressToken.toString());
         return(StatusCode::FAILURE);
      }
      token = std::make_unique<Token>();
      token->fromString(static_cast<const char*>(buffer)); buffer = nullptr;
      if (token->classID() == Guid::null()) {
         token.reset();
      }
      m_inputStreamingTool->getObject(&buffer, nbytes).ignore();
   } else {
      token.reset (m_poolSvc->getToken(par[0], par[1], ip[0]));
   }
   if (token == nullptr) {
      return(StatusCode::RECOVERABLE);
   }
   refpAddress = new TokenAddress(POOL_StorageType, 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 198 of file AthenaPoolCnvSvc.cxx.

                                                                                        {
   assert(pAddress);
   std::string objName = "ALL";
   if (m_useDetailChronoStat.value()) {
      if (m_clidSvc->getTypeNameOfID(pAddress->clID(), objName).isFailure()) {
         std::ostringstream oss;
         oss << std::dec << pAddress->clID();
         objName = oss.str();
      }
      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.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->getInputContextMap().size();
         const unsigned int auxContext = m_poolSvc->getInputContext(tokAddr->getToken()->classID().toString() + tokAddr->getToken()->dbID().toString(), 1);
         char text[32];
         ::sprintf(text, "[CTXT=%08X]", auxContext);
         if (m_poolSvc->getInputContextMap().size() > maxContext) {
            if (m_poolSvc->setAttribute("TREE_CACHE", "0", pool::DbType(pool::ROOTTREE_StorageType).type(), "FID:" + tokAddr->getToken()->dbID().toString(), m_persSvcPerInputType.value(), auxContext).isSuccess()) {
               ATH_MSG_DEBUG("setInputAttribute failed to switch off TTreeCache for id = " << auxContext << ".");
            }
         }
         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 232 of file AthenaPoolCnvSvc.cxx.

                                                                                        {
   assert(pObject);
   std::string objName = "ALL";
   if (m_useDetailChronoStat.value()) {
      if (m_clidSvc->getTypeNameOfID(pObject->clID(), objName).isFailure()) {
         std::ostringstream oss;
         oss << std::dec << pObject->clID();
         objName = oss.str();
      }
      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);
}

decodeOutputSpec()

StatusCode AthenaPoolCnvSvc::decodeOutputSpec ( std::string &  connectionSpec, int &  outputTech  ) const

overridevirtual

Extract/deduce the DB technology from the connection string/file specification.

Definition at line 1028 of file AthenaPoolCnvSvc.cxx.

{
  if (fileSpec.starts_with ( "oracle") || fileSpec.starts_with ( "mysql")) {
      outputTech = pool::POOL_RDBMS_StorageType.type();
   } else if (fileSpec.starts_with ( "ROOTKEY:")) {
      outputTech = pool::ROOTKEY_StorageType.type();
      fileSpec.erase(0, 8);
   } else if (fileSpec.starts_with ( "ROOTTREE:")) {
      outputTech = pool::ROOTTREE_StorageType.type();
      fileSpec.erase(0, 9);
   } else if (fileSpec.starts_with ( "ROOTTREEINDEX:")) {
      outputTech = pool::ROOTTREEINDEX_StorageType.type();
      fileSpec.erase(0, 14);
   } else if (fileSpec.starts_with ( "ROOTRNTUPLE:")) {
      outputTech = pool::ROOTRNTUPLE_StorageType.type();
      fileSpec.erase(0, 12);
   } else if (outputTech == 0) {
      outputTech = m_dbType.type();
   }
   return(StatusCode::SUCCESS);
}

disconnectOutput()

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

overridevirtual

Disconnect to the output connection.

Definition at line 713 of file AthenaPoolCnvSvc.cxx.

                                                                                   {
   std::string outputConnection = outputConnectionSpec.substr(0, outputConnectionSpec.find('['));
   if (!m_outputStreamingTool.empty() && m_outputStreamingTool->isClient()
       && (!m_parallelCompression || outputConnectionSpec.find("[PoolContainerPrefix=" + m_metadataContainerProp.value() + "]") != std::string::npos)) {
      return(StatusCode::SUCCESS);
   }
   if (!m_outputStreamingTool.empty() && !m_outputStreamingTool->isClient()) {
      if (m_streamServerActive) {
         m_streamServerActive = false;
         ATH_MSG_DEBUG("disconnectOutput SKIPPED to expire server.");
         return(StatusCode::SUCCESS);
      } else {
         m_streamServerActive = false;
      }
      ATH_MSG_DEBUG("disconnectOutput not SKIPPED for server.");
   }
   if (!m_outputStreamingTool.empty() && m_outputStreamingTool->isClient() && m_parallelCompression) {
      outputConnection += m_streamPortString.value();
   }
   unsigned int contextId = outputContextId(outputConnection);
   StatusCode sc = m_poolSvc->disconnect(contextId);
   return sc;
}

extractPoolAttributes()

void AthenaPoolCnvSvc::extractPoolAttributes ( const StringArrayProperty &  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 1259 of file AthenaPoolCnvSvc.cxx.

                                                         {
   std::vector<std::string> opt;
   std::string attributeName, containerName, databaseName, valueString;
   for (std::vector<std::string>::const_iterator iter = property.value().begin(),
           last = property.value().end(); iter != last; ++iter) {
      opt.clear();
      attributeName.clear();
      containerName.clear();
      databaseName.clear();
      valueString.clear();
      using Gaudi::Utils::AttribStringParser;
      for (const AttribStringParser::Attrib& attrib : AttribStringParser (*iter)) {
         const std::string tag = attrib.tag;
         const std::string val = attrib.value;
         if (tag == "DatabaseName") {
            databaseName = val;
         } else if (tag == "ContainerName") {
            if (databaseName.empty()) {
               databaseName = "*";
            }
            containerName = val;
         } else {
            attributeName = tag;
            valueString = val;
         }
      }
      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 265 of file AthenaPoolCnvSvc.cxx.

                                                                                      {
   assert(pObject);
   std::string objName = "ALL";
   if (m_useDetailChronoStat.value()) {
      if (m_clidSvc->getTypeNameOfID(pObject->clID(), objName).isFailure()) {
         std::ostringstream oss;
         oss << std::dec << pObject->clID();
         objName = oss.str();
      }
      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 146 of file AthenaPoolCnvSvc.cxx.

                                      {
   ATH_MSG_VERBOSE("Finalizing...");
   // Some algorithms write in finalize(), flush DHForms if any are left
   flushDataHeaderForms();
   // Release AthenaSerializeSvc
   if (!m_serializeSvc.empty()) {
      if (!m_serializeSvc.release().isSuccess()) {
         ATH_MSG_WARNING("Cannot release AthenaSerializeSvc.");
      }
   }
   // Release OutputStreamingTool (if configured)
   if (!m_outputStreamingTool.empty()) {
      if (!m_outputStreamingTool.release().isSuccess()) {
         ATH_MSG_WARNING("Cannot release Output AthenaIPCTool.");
      }
   }
   // Release InputStreamingTool (if configured)
   if (!m_inputStreamingTool.empty()) {
      if (!m_inputStreamingTool.release().isSuccess()) {
         ATH_MSG_WARNING("Cannot release Input AthenaIPCTool.");
      }
   }
   // 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 132 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 744 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 1243 of file AthenaPoolCnvSvc.cxx.

                                                      {
   if (incident.type() == "StoreCleared" && m_outputStreamingTool->isClient() && !m_parallelCompression) {
      m_outputStreamingTool->lockObject("release").ignore();
   }
   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 39 of file AthenaPoolCnvSvc.cxx.

                                        {
   // Initialize DataModelCompatSvc
   ServiceHandle<IService> dmcsvc("DataModelCompatSvc", this->name());
   ATH_CHECK(dmcsvc.retrieve());
   // Retrieve PoolSvc
   ATH_CHECK(m_poolSvc.retrieve());
   // Retrieve ClassIDSvc
   ATH_CHECK(m_clidSvc.retrieve());
   // Retrieve InputStreamingTool (if configured)
   if (!m_inputStreamingTool.empty()) {
      ATH_CHECK(m_inputStreamingTool.retrieve());
   }
   // Retrieve OutputStreamingTool (if configured)
   if (!m_outputStreamingTool.empty()) {
      ATH_CHECK(m_outputStreamingTool.retrieve());
      if (m_makeStreamingToolClient.value() == -1) {
        // Initialize AthenaRootSharedWriter
        ServiceHandle<IService> arswsvc("AthenaRootSharedWriterSvc", this->name());
        ATH_CHECK(arswsvc.retrieve());
      }
      // Put PoolSvc into share mode to avoid duplicating catalog.
      m_poolSvc->setShareMode(true);
   }
   if (!m_inputStreamingTool.empty() || !m_outputStreamingTool.empty()) {
      // Retrieve AthenaSerializeSvc
      ATH_CHECK(m_serializeSvc.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);
   }
   // Extracting MaxFileSizes for global default and map by Database name.
   for (std::vector<std::string>::const_iterator iter = m_maxFileSizes.value().begin(),
       last = m_maxFileSizes.value().end(); iter != last; ++iter) {
      if (auto p = iter->find('='); p != std::string::npos) {
         long long maxFileSize = atoll(iter->data() + (p + 1));
         std::string databaseName = iter->substr(0, iter->find_first_of("   ="));
         m_databaseMaxFileSize.insert(std::make_pair(databaseName, maxFileSize));
      } else {
         m_domainMaxFileSize = atoll(iter->c_str());
      }
   }
   ATH_MSG_DEBUG("Setting StorageType to " << m_storageTechProp.value());
   m_dbType = pool::DbType::getType( m_storageTechProp.value() );
   if( m_dbType == TEST_StorageType ) {
      ATH_MSG_FATAL("Unknown StorageType rquested: " << m_storageTechProp.value());
      return StatusCode::FAILURE;
   }
   if( m_containerPrefixProp.value() == "Default" ) {
      // select default storage element name accoring to storage tech
      if( m_dbType.exactMatch(pool::ROOTRNTUPLE_StorageType) ) m_containerPrefixProp.setValue( APRDefaults::RNTupleNames::EventData );
      else m_containerPrefixProp.setValue( APRDefaults::TTreeNames::EventData );
   }
 
   // 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.");
   }
 
   if (!m_outputStreamingTool.empty()) {
      incSvc->addListener(this, "StoreCleared", pri);
      ATH_MSG_DEBUG("Subscribed to StoreCleared");
   }
   // 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 193 of file AthenaPoolCnvSvc.cxx.

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

io_reinit()

StatusCode AthenaPoolCnvSvc::io_reinit ( )

overridevirtual

Definition at line 126 of file AthenaPoolCnvSvc.cxx.

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

makeClient()

StatusCode AthenaPoolCnvSvc::makeClient ( int  num )

overridevirtual

Make this a client.

Definition at line 1123 of file AthenaPoolCnvSvc.cxx.

                                               {
   if (!m_outputStreamingTool.empty()) {
      ATH_MSG_DEBUG("makeClient: " << m_outputStreamingTool << " = " << num);
      std::string streamPortSuffix;
      if (m_outputStreamingTool->makeClient(num, streamPortSuffix).isFailure()) {
         ATH_MSG_ERROR("makeClient: " << m_outputStreamingTool << " failed");
         return(StatusCode::FAILURE);
      } else if (m_streamPortString.value().find("localhost:0") != std::string::npos) {
         // We don't seem to use a dedicated port per stream so doing this for the first client is probably OK
         ATH_MSG_DEBUG("makeClient: Setting conversion service port suffix to " << streamPortSuffix);
         m_streamPortString.setValue(streamPortSuffix);
      }
   }
   if (m_inputStreamingTool.empty()) {
      return(StatusCode::SUCCESS);
   }
   ATH_MSG_DEBUG("makeClient: " << m_inputStreamingTool << " = " << num);
   std::string dummyStr;
   return(m_inputStreamingTool->makeClient(num, dummyStr));
}

makeServer()

StatusCode AthenaPoolCnvSvc::makeServer ( int  num )

overridevirtual

Make this a server.

Definition at line 1097 of file AthenaPoolCnvSvc.cxx.

                                               {
   if (num < 0) {
      num = -num;
      m_streamServerActive = true;
      num = num % 1024;
      if (!m_outputStreamingTool.empty() && !m_outputStreamingTool->isServer()) {
         ATH_MSG_DEBUG("makeServer: " << m_outputStreamingTool << " = " << num);
         ATH_MSG_DEBUG("makeServer: Calling shared memory tool with port suffix " << m_streamPortString);
         const std::string streamPortSuffix = m_streamPortString.value();
         if (m_outputStreamingTool->makeServer(num, streamPortSuffix).isFailure()) {
            ATH_MSG_ERROR("makeServer: " << m_outputStreamingTool << " failed");
            return(StatusCode::FAILURE);
         }
         // Disable PersistencySvc per output file mode, for SharedWriter Server
         m_persSvcPerOutput.setValue(false);
         return(StatusCode::SUCCESS);
      }
      return(StatusCode::RECOVERABLE);
   }
   if (m_inputStreamingTool.empty()) {
      return(StatusCode::RECOVERABLE);
   }
   ATH_MSG_DEBUG("makeServer: " << m_inputStreamingTool << " = " << num);
   return(m_inputStreamingTool->makeServer(num, ""));
}

outputContextId()

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

private

Definition at line 738 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 1315 of file AthenaPoolCnvSvc.cxx.

                            {
   bool retError = false;
   if (!m_inputStreamingTool.empty() && m_inputStreamingTool->isClient()) doGet = false;
   for (std::vector<std::vector<std::string> >::iterator iter = attr.begin(), last = attr.end();
           iter != last; ++iter) {
      if (iter->size() == 2) {
         const std::string& opt = (*iter)[0];
         std::string data = (*iter)[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) {
                  iter->clear();
               }
            } else {
               ATH_MSG_DEBUG("setAttribute failed for domain attr " << opt << " to " << data);
               retError = true;
            }
         }
      }
      if (iter->size() == 4) {
         const std::string& opt = (*iter)[0];
         std::string data = (*iter)[1];
         const std::string& file = (*iter)[2];
         const std::string& cont = (*iter)[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) {
                        (*iter)[2] += "," + fileName + ",";
                     } else {
                        iter->clear();
                     }
                  }
               } else {
                  ATH_MSG_DEBUG("setAttribute failed for " << opt << " to " << data << " for db: " << fileName << " and cont: " << cont);
                  retError = true;
               }
            }
         }
      }
   }
   for (std::vector<std::vector<std::string> >::iterator iter = attr.begin(); iter != attr.end(); ) {
      if (iter->empty()) {
         iter = attr.erase(iter);
      } else {
         ++iter;
      }
   }
   return(retError ? StatusCode::FAILURE : StatusCode::SUCCESS);
}

readData()

StatusCode AthenaPoolCnvSvc::readData ( )

overridevirtual

Read the next data object.

Definition at line 1144 of file AthenaPoolCnvSvc.cxx.

                                      {
   if (m_inputStreamingTool.empty()) {
      return(StatusCode::FAILURE);
   }
   const char* tokenStr = nullptr;
   int num = -1;
   StatusCode sc = m_inputStreamingTool->clearObject(&tokenStr, num);
   if (sc.isSuccess() && tokenStr != nullptr && strlen(tokenStr) > 0 && num > 0) {
      ATH_MSG_DEBUG("readData: " << tokenStr << ", for client: " << num);
   } else {
      return(sc);
   }
   // Read object instance via POOL/ROOT
   void* instance = nullptr;
   Token token;
   token.fromString(tokenStr); tokenStr = nullptr;
   if (token.classID() != Guid::null()) {
      std::string objName = "ALL";
      if (m_useDetailChronoStat.value()) {
         objName = token.classID().toString();
      }
      // StopWatch listens from here until the end of this current scope
      PMonUtils::BasicStopWatch stopWatchInner("cObj_" + objName, m_chronoMap);
      this->setObjPtr(instance, &token);
      // Serialize object via ROOT
      RootType cltype(pool::DbReflex::forGuid(token.classID()));
      void* buffer = nullptr;
      std::size_t nbytes = 0;
      buffer = m_serializeSvc->serialize(instance, cltype, nbytes);
      sc = m_inputStreamingTool->putObject(buffer, nbytes, num);
      while (sc.isRecoverable()) {
         sc = m_inputStreamingTool->putObject(buffer, nbytes, num);
      }
      delete [] static_cast<char*>(buffer); buffer = nullptr;
      if (!sc.isSuccess()) {
         ATH_MSG_ERROR("Could not share object for: " << token.toString());
         return(StatusCode::FAILURE);
      }
      AuxDiscoverySvc auxDiscover;
      if (!auxDiscover.sendStore(m_serializeSvc.get(), m_inputStreamingTool.get(), instance, token.classID(), token.contID(), num).isSuccess()) {
         ATH_MSG_ERROR("Could not share dynamic aux store for: " << token.toString());
         return(StatusCode::FAILURE);
      }
      cltype.Destruct(instance); instance = nullptr;
      if (!m_inputStreamingTool->putObject(nullptr, 0, num).isSuccess()) {
         ATH_MSG_ERROR("Could not share object for: " << token.toString());
         return(StatusCode::FAILURE);
      }
   } else if (token.dbID() != Guid::null()) {
      std::string returnToken;
      const Token* metadataToken = m_poolSvc->getToken("FID:" + token.dbID().toString(), token.contID(), token.oid().first);
      if (metadataToken != nullptr) {
         returnToken = metadataToken->toString();
      } else {
         returnToken = token.toString();
      }
      delete metadataToken; metadataToken = nullptr;
      // Share token
      sc = m_inputStreamingTool->putObject(returnToken.c_str(), returnToken.size() + 1, num);
      if (!sc.isSuccess() || !m_inputStreamingTool->putObject(nullptr, 0, num).isSuccess()) {
         ATH_MSG_ERROR("Could not share token for: " << token.toString());
         return(StatusCode::FAILURE);
      }
   } else {
      return(StatusCode::RECOVERABLE);
   }
   return(StatusCode::SUCCESS);
}

registerCleanUp()

StatusCode AthenaPoolCnvSvc::registerCleanUp ( IAthenaPoolCleanUp *  cnv )

overridevirtual

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

Definition at line 1050 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 748 of file AthenaPoolCnvSvc.cxx.

                                                                                                          {
   // StopWatch listens from here until the end of this current scope
   PMonUtils::BasicStopWatch stopWatch("cRepR_ALL", m_chronoMap);
   if (m_makeStreamingToolClient.value() > 0 && !m_outputStreamingTool.empty() && !m_outputStreamingTool->isServer() && !m_outputStreamingTool->isClient()) {
      if (!makeClient(m_makeStreamingToolClient.value()).isSuccess()) {
         ATH_MSG_ERROR("Could not make AthenaPoolCnvSvc a Share Client");
         return(nullptr);
      }
   }
   Token* token = nullptr;
   if (!m_outputStreamingTool.empty() && m_outputStreamingTool->isClient()
       && (!m_parallelCompression || placement->containerName().compare(0, m_metadataContainerProp.value().size(), m_metadataContainerProp.value()) == 0)) {
      // Lock object
      std::string placementStr = placement->toString();
      placementStr += "[PNAME=";
      placementStr += classDesc.Name();
      placementStr += ']';
      ATH_MSG_VERBOSE("Requesting write object for: " << placementStr);
      StatusCode sc = m_outputStreamingTool->lockObject(placementStr.c_str());
      while (sc.isRecoverable()) {
         //usleep(100);
         sc = m_outputStreamingTool->lockObject(placementStr.c_str());
      }
      if (!sc.isSuccess()) {
         ATH_MSG_ERROR("Failed to lock Data for " << placementStr);
         return(nullptr);
      }
      // Serialize object via ROOT
      const void* buffer = nullptr;
      std::size_t nbytes = 0;
      bool own = true;
      if (classDesc.Name() == "Token") {
         nbytes = strlen(static_cast<const char*>(obj)) + 1;
         buffer = obj;
         own = false;
      } else if (classDesc.IsFundamental()) {
         nbytes = classDesc.SizeOf();
         buffer = obj;
         own = false;
      } else {
         buffer = m_serializeSvc->serialize(obj, classDesc, nbytes);
      }
      // Share object
      sc = m_outputStreamingTool->putObject(buffer, nbytes);
      while (sc.isRecoverable()) {
         //usleep(100);
         sc = m_outputStreamingTool->putObject(buffer, nbytes);
      }
      if (own) { delete [] static_cast<const char*>(buffer); }
      buffer = nullptr;
      if (!sc.isSuccess()) {
         ATH_MSG_ERROR("Could not share object for: " << placementStr);
         m_outputStreamingTool->putObject(nullptr, 0).ignore();
         return(nullptr);
      }
      AuxDiscoverySvc auxDiscover;
      if (!auxDiscover.sendStore(m_serializeSvc.get(), m_outputStreamingTool.get(), obj, pool::DbReflex::guid(classDesc), placement->containerName()).isSuccess()) {
         ATH_MSG_ERROR("Could not share dynamic aux store for: " << placementStr);
         m_outputStreamingTool->putObject(nullptr, 0).ignore();
         return(nullptr);
      }
      if (!m_outputStreamingTool->putObject(nullptr, 0).isSuccess()) {
         ATH_MSG_ERROR("Failed to put Data for " << placementStr);
         return(nullptr);
      }
      // Get Token back from Server
      const char* tokenStr = nullptr;
      int num = -1;
      sc = m_outputStreamingTool->clearObject(&tokenStr, num);
      while (sc.isRecoverable()) {
         //usleep(100);
         sc = m_outputStreamingTool->clearObject(&tokenStr, num);
      }
      if (!sc.isSuccess()) {
         ATH_MSG_ERROR("Failed to get Token");
         return(nullptr);
      }
      if (!strcmp(tokenStr, "ABORT")) {
         ATH_MSG_ERROR("Writer requested ABORT");
         // tell the server we are leaving
         m_outputStreamingTool->stop().ignore();
         return nullptr;
      }
      Token* tempToken = new Token();
      tempToken->fromString(tokenStr); tokenStr = nullptr;
      tempToken->setClassID(pool::DbReflex::guid(classDesc));
      token = tempToken; tempToken = nullptr;
// Client Write Request
   } else {
      if (!m_outputStreamingTool.empty() && !m_outputStreamingTool->isClient() && !m_outputStreamingTool->isServer()) {
         ATH_MSG_DEBUG("registerForWrite SKIPPED for uninitialized server, Placement = " << placement->toString());
         Token* tempToken = new Token();
         tempToken->setClassID(pool::DbReflex::guid(classDesc));
         token = tempToken; tempToken = nullptr;
      } else if (!m_outputStreamingTool.empty() && !m_outputStreamingTool->isClient() && !m_streamServerActive) {
         ATH_MSG_DEBUG("Requested write object for: " << placement->toString());
         token = m_poolSvc->registerForWrite(placement, obj, classDesc);
      } else {
         if (!m_outputStreamingTool.empty() && m_outputStreamingTool->isClient() && m_parallelCompression) {
            placement->setFileName(placement->fileName() + m_streamPortString.value());
         }
         if (m_persSvcPerOutput) { // Use separate PersistencySvc for each output stream/file
            char text[32];
            ::sprintf(text, "[CTXT=%08X]", m_poolSvc->getOutputContext(placement->fileName()));
            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 1076 of file AthenaPoolCnvSvc.cxx.

                                                                         {
   // Set attributes for input file
   m_lastInputFileName = fileName; // Save file name for printing attributes per event
   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.");
   }
   if (!m_persSvcPerInputType.empty()) {
      // Loop over all extra event input contexts and switch off TTreeCache
      const auto& extraInputContextMap = m_poolSvc->getInputContextMap();
      for (const auto& [label, id]: extraInputContextMap) {
         if (m_poolSvc->setAttribute("TREE_CACHE", "0", pool::DbType(pool::ROOTTREE_StorageType).type(), m_lastInputFileName, m_persSvcPerInputType.value(), id).isSuccess()) {
            ATH_MSG_DEBUG("setInputAttribute failed to switch off TTreeCache for = " << label << ".");
         }
      }
   }
   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 860 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 stopWatchOuter("cObjR_ALL", m_chronoMap);
   if (m_makeStreamingToolClient.value() > 0 && !m_inputStreamingTool.empty() && !m_inputStreamingTool->isServer() && !m_inputStreamingTool->isClient()) {
      if (!makeClient(-m_makeStreamingToolClient.value()).isSuccess()) {
         ATH_MSG_ERROR("Could not make AthenaPoolCnvSvc a Share Client");
      }
   }
   if (!m_outputStreamingTool.empty() && m_outputStreamingTool->isServer()) {
      if (token->dbID() == Guid::null()) {
         int num = token->oid().first;
         // Get object from SHM
         void* buffer = nullptr;
         std::size_t nbytes = 0;
         StatusCode sc = m_outputStreamingTool->getObject(&buffer, nbytes, num);
         while (sc.isRecoverable()) {
            //usleep(100);
            sc = m_outputStreamingTool->getObject(&buffer, nbytes, num);
         }
         if (!sc.isSuccess()) {
            ATH_MSG_ERROR("Failed to get Data for " << token->toString());
            obj = nullptr;
         } else {
            ATH_MSG_DEBUG("Server deserializing " << token->toString());
            if (token->classID() != Guid::null()) {
               // Deserialize object
               RootType cltype(pool::DbReflex::forGuid(token->classID()));
               obj = m_serializeSvc->deserialize(buffer, nbytes, cltype); buffer = nullptr;
            } else {
               // Deserialize object
               std::string className = token->auxString();
               className = className.substr(className.find("[PNAME="));
               className = className.substr(7, className.find(']') - 7);
               RootType cltype(RootType::ByNameNoQuiet(className));
               obj = m_serializeSvc->deserialize(buffer, nbytes, cltype); buffer = nullptr;
            }
            AuxDiscoverySvc auxDiscover;
            if (!auxDiscover.receiveStore(m_serializeSvc.get(), m_outputStreamingTool.get(), obj, num).isSuccess()) {
               ATH_MSG_ERROR("Failed to get Dynamic Aux Store for " << token->toString());
               obj = nullptr;
            }
         }
      }
   }
   if (!m_inputStreamingTool.empty() && m_inputStreamingTool->isClient() && (m_streamingTechnology.value() < 0 || token->technology() == m_streamingTechnology.value())) {
      ATH_MSG_VERBOSE("Requesting remote object for: " << token->toString());
      if (!m_inputStreamingTool->lockObject(token->toString().c_str()).isSuccess()) {
         ATH_MSG_ERROR("Failed to lock Data for " << token->toString());
         obj = nullptr;
      } else {
         void* buffer = nullptr;
         std::size_t nbytes = 0;
         StatusCode sc = StatusCode::FAILURE;
         // StopWatch listens from here until the end of this current scope
         {
            PMonUtils::BasicStopWatch stopWatchInner("gObj_ALL", m_chronoMap);
            sc = m_inputStreamingTool->getObject(&buffer, nbytes);
            while (sc.isRecoverable()) {
               // sleep
               sc = m_inputStreamingTool->getObject(&buffer, nbytes);
            }
         }
         if (!sc.isSuccess()) {
            ATH_MSG_ERROR("Failed to get Data for " << token->toString());
            obj = nullptr;
         } else {
            obj = m_serializeSvc->deserialize(buffer, nbytes, token->classID()); buffer = nullptr;
            AuxDiscoverySvc auxDiscover;
            if (!auxDiscover.receiveStore(m_serializeSvc.get(), m_inputStreamingTool.get(), obj).isSuccess()) {
               ATH_MSG_ERROR("Failed to get Dynamic Aux Store for " << token->toString());
               obj = nullptr;
            }
         }
      }
   } else if (token->dbID() != Guid::null()) {
      ATH_MSG_VERBOSE("Requesting object for: " << token->toString());
      m_poolSvc->setObjPtr(obj, token);
   }
}

stop()

StatusCode AthenaPoolCnvSvc::stop ( )

finaloverridevirtual

Definition at line 139 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 941 of file AthenaPoolCnvSvc.cxx.

                                                 {
   return(m_useDetailChronoStat.value());
}

Friends And Related Function Documentation

SvcFactory< AthenaPoolCnvSvc >

friend class SvcFactory< AthenaPoolCnvSvc >

friend

Definition at line 1 of file AthenaPoolCnvSvc.h.

Member Data Documentation

m_branchNameHintProp

StringProperty AthenaPoolCnvSvc::m_branchNameHintProp {this,"SubLevelBranchName", "<type>/<key>"}

private

SubLevelBranchName, naming hint policy for POOL branching: ("" = no branching)

Definition at line 218 of file AthenaPoolCnvSvc.h.

m_chronoMap

PMonUtils::BasicStopWatchResultMap_t AthenaPoolCnvSvc::m_chronoMap {}

private

Map that holds chrono information.

Definition at line 203 of file AthenaPoolCnvSvc.h.

m_clidSvc

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

private

Definition at line 195 of file AthenaPoolCnvSvc.h.

m_containerAttr

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

private

Definition at line 224 of file AthenaPoolCnvSvc.h.

m_containerNameHintProp

StringProperty AthenaPoolCnvSvc::m_containerNameHintProp {this,"TopLevelContainerName",""}

private

TopLevelContainerName, naming hint policy for top level POOL container: default = "<type>".

Definition at line 216 of file AthenaPoolCnvSvc.h.

m_containerPrefixProp

StringProperty AthenaPoolCnvSvc::m_containerPrefixProp {this,"PoolContainerPrefix","Default"}

private

POOL Container name prefix - will be part of or whole TTree/RNTuple name 'Default' takes the prefix from APRDefaults according to StorageTech.

Definition at line 214 of file AthenaPoolCnvSvc.h.

m_contextAttr

std::vector<unsigned int> AthenaPoolCnvSvc::m_contextAttr

private

Definition at line 225 of file AthenaPoolCnvSvc.h.

m_databaseAttr

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

private

Definition at line 223 of file AthenaPoolCnvSvc.h.

m_databaseMaxFileSize

std::map<std::string, long long> AthenaPoolCnvSvc::m_databaseMaxFileSize

private

Definition at line 239 of file AthenaPoolCnvSvc.h.

m_dbType

pool::DbType AthenaPoolCnvSvc::m_dbType

private

decoded storage tech requested in "StorageTechnology" property

Definition at line 192 of file AthenaPoolCnvSvc.h.

m_DHFilterAliases

BooleanProperty AthenaPoolCnvSvc::m_DHFilterAliases { this, "doFilterDHAliases", true }

private

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

Definition at line 272 of file AthenaPoolCnvSvc.h.

m_DHFormCacheSize

IntegerProperty AthenaPoolCnvSvc::m_DHFormCacheSize { this, "maxDHFormCacheSize", 100 }

private

Property for DataHeaderCnv input DHForm cache size.

Definition at line 270 of file AthenaPoolCnvSvc.h.

m_domainAttr

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

private

Definition at line 222 of file AthenaPoolCnvSvc.h.

m_domainMaxFileSize

long long AthenaPoolCnvSvc::m_domainMaxFileSize =std::numeric_limits<long long>::max()

private

Definition at line 238 of file AthenaPoolCnvSvc.h.

m_fileCommitCounter

std::map<std::string, int> AthenaPoolCnvSvc::m_fileCommitCounter

private

Definition at line 226 of file AthenaPoolCnvSvc.h.

m_fileFlushSetting

std::map<std::string, int> AthenaPoolCnvSvc::m_fileFlushSetting

private

Definition at line 227 of file AthenaPoolCnvSvc.h.

m_inputAttr

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

private

Definition at line 230 of file AthenaPoolCnvSvc.h.

m_inputAttrPerEvent

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

private

Definition at line 234 of file AthenaPoolCnvSvc.h.

m_inputPoolAttr

StringArrayProperty AthenaPoolCnvSvc::m_inputPoolAttr {this,"InputPoolAttributes",{}}

private

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

Definition at line 229 of file AthenaPoolCnvSvc.h.

m_inputPoolAttrPerEvent

StringArrayProperty 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 233 of file AthenaPoolCnvSvc.h.

m_inputStreamingTool

ToolHandle<IAthenaIPCTool> AthenaPoolCnvSvc::m_inputStreamingTool {this,"InputStreamingTool",{}}

private

Definition at line 197 of file AthenaPoolCnvSvc.h.

m_lastInputFileName

std::string AthenaPoolCnvSvc::m_lastInputFileName

private

Definition at line 193 of file AthenaPoolCnvSvc.h.

m_makeStreamingToolClient

IntegerProperty AthenaPoolCnvSvc::m_makeStreamingToolClient {this,"MakeStreamingToolClient",0}

private

Make this instance a Streaming Client during first connect/write automatically.

Definition at line 257 of file AthenaPoolCnvSvc.h.

m_maxFileSizes

StringArrayProperty AthenaPoolCnvSvc::m_maxFileSizes {this,"MaxFileSizes",{}}

private

MaxFileSizes, vector with maximum file sizes for Athena POOL output files.

Definition at line 237 of file AthenaPoolCnvSvc.h.

m_metadataClient

int AthenaPoolCnvSvc::m_metadataClient =0

private

Definition at line 200 of file AthenaPoolCnvSvc.h.

m_metadataContainerProp

StringProperty AthenaPoolCnvSvc::m_metadataContainerProp {this,"OutputMetadataContainer","MetaData"}

private

For SharedWriter: To use MetadataSvc to merge data placed in a certain container.

Definition at line 253 of file AthenaPoolCnvSvc.h.

m_metadataContainersAug

StringArrayProperty AthenaPoolCnvSvc::m_metadataContainersAug {this, "OutputMetadataContainers", {}, "Metadata containers used for augmentations"}

private

Definition at line 254 of file AthenaPoolCnvSvc.h.

m_mutex

std::mutex AthenaPoolCnvSvc::m_mutex

private

Definition at line 249 of file AthenaPoolCnvSvc.h.

m_numberEventsPerWrite

IntegerProperty AthenaPoolCnvSvc::m_numberEventsPerWrite {this,"NumberEventsPerWrite",-1}

private

When using TMemFile call Write on number of Events, respecting CollectionTree auto_flush.

Definition at line 265 of file AthenaPoolCnvSvc.h.

m_oneDataHeaderForm

BooleanProperty AthenaPoolCnvSvc::m_oneDataHeaderForm { this, "OneDataHeaderForm", false }

private

If true, use only one DataHeaderForm per Stream.

Definition at line 268 of file AthenaPoolCnvSvc.h.

m_outputStreamingTool

ToolHandle<IAthenaIPCTool> AthenaPoolCnvSvc::m_outputStreamingTool {this,"OutputStreamingTool",{}}

private

Definition at line 198 of file AthenaPoolCnvSvc.h.

m_parallelCompression

BooleanProperty AthenaPoolCnvSvc::m_parallelCompression {this,"ParallelCompression",true}

private

Use Athena Object sharing for metadata only, event data is collected and send via ROOT TMemFile.

Definition at line 261 of file AthenaPoolCnvSvc.h.

m_persSvcPerInputType

StringProperty AthenaPoolCnvSvc::m_persSvcPerInputType {this,"PersSvcPerInputType",""}

private

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 248 of file AthenaPoolCnvSvc.h.

m_persSvcPerOutput

BooleanProperty AthenaPoolCnvSvc::m_persSvcPerOutput {this,"PersSvcPerOutput",true}

private

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

default = true.

Definition at line 243 of file AthenaPoolCnvSvc.h.

m_poolAttr

StringArrayProperty 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 221 of file AthenaPoolCnvSvc.h.

m_poolSvc

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

private

Definition at line 194 of file AthenaPoolCnvSvc.h.

m_serializeSvc

ServiceHandle<IAthenaSerializeSvc> AthenaPoolCnvSvc::m_serializeSvc {this,"AthenaRootSerializeSvc","AthenaRootSerializeSvc"}

private

Definition at line 196 of file AthenaPoolCnvSvc.h.

m_storageTechProp

StringProperty AthenaPoolCnvSvc::m_storageTechProp {this,"StorageTechnology", "ROOTTREEINDEX"}

private

Default Storage Tech for containers (ROOTTREE, ROOTTREEINDEX, ROOTRNTUPLE)

Definition at line 211 of file AthenaPoolCnvSvc.h.

m_streamingTechnology

IntegerProperty AthenaPoolCnvSvc::m_streamingTechnology {this,"StreamingTechnology",-1}

private

Use Streaming for selected technologies only.

Definition at line 259 of file AthenaPoolCnvSvc.h.

m_streamPortString

StringProperty AthenaPoolCnvSvc::m_streamPortString {this,"StreamPortString","?pmerge=localhost:0"}

private

Extension to use ROOT TMemFile for event data, "?pmerge=<host>:<port>".

Definition at line 263 of file AthenaPoolCnvSvc.h.

m_streamServerActive

bool AthenaPoolCnvSvc::m_streamServerActive =false

private

Definition at line 199 of file AthenaPoolCnvSvc.h.

m_useDetailChronoStat

BooleanProperty AthenaPoolCnvSvc::m_useDetailChronoStat {this,"UseDetailChronoStat",false}

private

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

Definition at line 208 of file AthenaPoolCnvSvc.h.

---

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

• AthenaPoolCnvSvc.h
• AthenaPoolCnvSvc.cxx