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 Types
typedef std::unordered_map< CLID, WorkerEntry >	Workers

Public Member Functions
StatusCode	initialize ()
	Required of all Gaudi Services. More...
StatusCode	io_reinit ()
StatusCode	finalize ()
	Required of all Gaudi Services. More...
StatusCode	io_finalize ()
StatusCode	queryInterface (const InterfaceID &riid, void **ppvInterface)
	Required of all Gaudi services: see Gaudi documentation for details. More...
StatusCode	createObj (IOpaqueAddress *pAddress, DataObject *&refpObject)
	Implementation of IConversionSvc: Create the transient representation of an object from persistent state. More...
StatusCode	createRep (DataObject *pObject, IOpaqueAddress *&refpAddress)
	Implementation of IConversionSvc: Convert the transient object to the requested representation. More...
StatusCode	fillRepRefs (IOpaqueAddress *pAddress, DataObject *pObject)
	Implementation of IConversionSvc: Resolve the references of the converted object. More...
StatusCode	connectOutput (const std::string &outputConnectionSpec, const std::string &openMode)
	Implementation of IConversionSvc: Connect to the output connection specification with open mode. More...
StatusCode	connectOutput (const std::string &outputConnectionSpec)
	Implementation of IConversionSvc: Connect to the output connection specification with open mode. More...
StatusCode	commitOutput (const std::string &outputConnectionSpec, bool doCommit)
	Implementation of IConversionSvc: Commit pending output. More...
StatusCode	disconnectOutput (const std::string &outputConnectionSpec)
	Disconnect to the output connection. More...
IPoolSvc *	getPoolSvc ()
Token *	registerForWrite (Placement *placement, const void *obj, const RootType &classDesc)
void	setObjPtr (void *&obj, const Token *token)
bool	useDetailChronoStat () const
StatusCode	createAddress (long svcType, const CLID &clid, const std::string *par, const unsigned long *ip, IOpaqueAddress *&refpAddress)
	Create a Generic address using explicit arguments to identify a single object. More...
StatusCode	createAddress (long svcType, const CLID &clid, const std::string &refAddress, IOpaqueAddress *&refpAddress)
	Create address from string form. More...
StatusCode	convertAddress (const IOpaqueAddress *pAddress, std::string &refAddress)
	Convert address to string form. More...
StatusCode	decodeOutputSpec (std::string &connectionSpec, int &outputTech) const
	Extract/deduce the DB technology from the connection string/file specification. More...
StatusCode	registerCleanUp (IAthenaPoolCleanUp *cnv)
	Implement registerCleanUp to register a IAthenaPoolCleanUp to be called during cleanUp. More...
StatusCode	cleanUp (const std::string &connection)
	Implement cleanUp to call all registered IAthenaPoolCleanUp cleanUp() function. More...
StatusCode	setInputAttributes (const std::string &fileName)
	Set the input file attributes, if any are requested from jobOpts. More...
virtual StatusCode	makeServer (int num)
	Make this a server. More...
virtual StatusCode	makeClient (int num)
	Make this a client. More...
virtual StatusCode	readData ()
	Read the next data object. More...
virtual StatusCode	commitCatalog ()
	Commit Catalog. More...
StatusCode	abortSharedWrClients (int client_n)
	Send abort to SharedWriter clients if the server quits on error. More...
void	handle (const Incident &incident)
	Implementation of IIncidentListener: Handle for EndEvent incidence. More...
	AthenaPoolCnvSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Standard Service Constructor. More...
virtual	~AthenaPoolCnvSvc ()=default
	Destructor. More...
MsgStream &	msg () const
MsgStream &	msg (const MSG::Level lvl) const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	Retrieve interface ID. More...

Protected Attributes
std::vector< IAthenaPoolCleanUp * >	m_cnvs

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...
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 >

@c IAddressCreator interface implementation
virtual StatusCode	updateServiceState (IOpaqueAddress *pAddress)
	Update state of the service. More...
typedef std::recursive_mutex	CallMutex
	Mutex to protect Converter creation. More...
SmartIF< IDataProviderSvc >	m_dataSvc
	Pointer to data provider service. More...
SmartIF< IAddressCreator >	m_addressCreator
	Pointer to the address creation service interface. More...
SmartIF< IConversionSvc >	m_cnvSvc
	Pointer to the IConversionSvc interface of this. More...
long	m_type
	Conversion service type. More...
Workers	m_workers
	List of conversion workers. More...
CallMutex	m_conv_mut
virtual SmartIF< IAddressCreator > &	addressCreator ()
	Retrieve address creation interface. More...
virtual IConverter *	createConverter (long typ, const CLID &clid, const ICnvFactory *fac)
	Create new Converter using factory. More...
virtual StatusCode	configureConverter (long typ, const CLID &clid, IConverter *cnv)
	Configure the new converter before initialize is called. More...
virtual StatusCode	initializeConverter (long typ, const CLID &clid, IConverter *cnv)
	Initialize the new converter. More...
virtual StatusCode	activateConverter (long typ, const CLID &clid, IConverter *cnv)
	Activate the new converter after initialization. More...
virtual void	loadConverter (DataObject *pObject)
	Load converter or dictionary needed by the converter. More...
StatusCode	makeCall (int typ, bool ignore_add, bool ignore_obj, bool update, IOpaqueAddress *&pAddress, DataObject *&pObject)

Detailed Description

This class provides the interface between Athena and PoolSvc.

Definition at line 41 of file AthenaPoolCnvSvc.h.

Member Typedef Documentation

CallMutex

typedef std::recursive_mutex AthCnvSvc::CallMutex

protectedinherited

Mutex to protect Converter creation.

Definition at line 323 of file AthCnvSvc.h.

Workers

typedef std::unordered_map<CLID,WorkerEntry> AthCnvSvc::Workers

inherited

Definition at line 106 of file AthCnvSvc.h.

Constructor & Destructor Documentation

AthenaPoolCnvSvc()

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

Standard Service Constructor.

Definition at line 1215 of file AthenaPoolCnvSvc.cxx.

                                                                                  :
    ::AthCnvSvc(name, pSvcLocator, POOL_StorageType),
    m_outputStreamingTool(this)
{
   declareProperty("OutputStreamingTool", m_outputStreamingTool);
}

~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 1184 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;
}

activateConverter()

StatusCode AthCnvSvc::activateConverter ( long  typ, const CLID &  clid, IConverter *  cnv  )

protectedvirtualinherited

Activate the new converter after initialization.

Definition at line 536 of file AthCnvSvc.cxx.

{
  if (cnv) {
    return StatusCode::SUCCESS;
  }
  return Status::NO_CONVERTER;
}

addConverter() [1/2]

StatusCode AthCnvSvc::addConverter ( const CLID &  clid )

virtualinherited

Add converter object to conversion service.

Definition at line 336 of file AthCnvSvc.cxx.

{
  // First look for the more specific converter
  long typ = repSvcType();
  IConverter* pConverter = createConverter(typ, clid, 0);
  if ( 0 != pConverter )    {
    StatusCode status = configureConverter( typ, clid, pConverter );
    if ( status.isSuccess() )   {
      status = initializeConverter( typ, clid, pConverter );
      if ( status.isSuccess() )   {
        status = activateConverter( typ, clid, pConverter );
        if ( status.isSuccess() )   {
          long conv_typ  = pConverter->repSvcType();
          const CLID&   conv_clid = pConverter->objType();
          typ      = (typ<0xFF) ? typ : typ&0xFFFFFF00;
          conv_typ = (conv_typ<0xFF) ? conv_typ : conv_typ&0xFFFFFF00;
          if ( conv_typ == typ && conv_clid == clid )   {
            return addConverter(pConverter);
          }
        }
      }
    }
    pConverter->release();
  }
  return Status::NO_CONVERTER;
}

addConverter() [2/2]

StatusCode AthCnvSvc::addConverter ( IConverter *  pConverter )

virtualinherited

Add converter object to conversion service.

Definition at line 365 of file AthCnvSvc.cxx.

{
  if ( 0 != pConverter )    {
    const CLID& clid = pConverter->objType();
    removeConverter(clid).ignore();
    m_workers.insert (std::make_pair(clid,WorkerEntry(clid, pConverter)));
    pConverter->addRef();
    return StatusCode::SUCCESS;
  }
  return Status::NO_CONVERTER;
}

addressCreator() [1/2]

virtual SmartIF<IAddressCreator>& AthCnvSvc::addressCreator ( )

inlineprotectedvirtualinherited

Retrieve address creation interface.

Definition at line 300 of file AthCnvSvc.h.

  {
    return m_addressCreator;
  }

addressCreator() [2/2]

SmartIF< IAddressCreator > & AthCnvSvc::addressCreator ( ) const

virtualinherited

Retrieve address creator facility.

Definition at line 261 of file AthCnvSvc.cxx.

{
  // FIXME: Ideally the return type should be const, but that would require
  //        changes in the Gaudi IConverter base class.
  SmartIF<IAddressCreator>& svc ATLAS_THREAD_SAFE =
    const_cast<SmartIF<IAddressCreator>&>(m_addressCreator);
  return svc;
}

cleanUp()

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

virtual

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

Implements IAthenaPoolCnvSvc.

Definition at line 1016 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 ( )

virtual

Commit Catalog.

Implements IDataShare.

Definition at line 1175 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  )

virtual

Implementation of IConversionSvc: Commit pending output.

Parameters

doCommit

[IN] boolean to force full commit

Reimplemented from AthCnvSvc.

Definition at line 392 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
                     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 = token->contID();
                        dataHeaderID += '/';
                        dataHeaderID += oss2.str();
                        dataHeaderID += '/';
                        dataHeaderID += 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);
}

configureConverter()

StatusCode AthCnvSvc::configureConverter ( long  typ, const CLID &  clid, IConverter *  cnv  )

protectedvirtualinherited

Configure the new converter before initialize is called.

Definition at line 510 of file AthCnvSvc.cxx.

{
  if (cnv) {
    cnv->setConversionSvc(this).ignore();
    cnv->setAddressCreator(m_addressCreator).ignore();
    cnv->setDataProvider(m_dataSvc).ignore();
    return StatusCode::SUCCESS;
  }
  return Status::NO_CONVERTER;
 
}

connectOutput() [1/2]

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

virtual

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

Parameters

outputConnectionSpec

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

Reimplemented from AthCnvSvc.

Definition at line 297 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  )

virtual

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.

Reimplemented from AthCnvSvc.

Definition at line 292 of file AthenaPoolCnvSvc.cxx.

                            {
   return(connectOutput(outputConnectionSpec));
}

conversionSvc()

SmartIF< IConversionSvc > & AthCnvSvc::conversionSvc ( ) const

virtualinherited

Implementation of IConverter: Get conversion service the converter is connected to.

Definition at line 232 of file AthCnvSvc.cxx.

{
  // FIXME: Ideally the return type should be const, but that would require
  //        changes in the Gaudi IConverter base class.
  SmartIF<IConversionSvc>& svc ATLAS_THREAD_SAFE =
    const_cast<SmartIF<IConversionSvc>&>(m_cnvSvc);
  return svc;
}

convertAddress()

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

virtual

Convert address to string form.

Parameters

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

Reimplemented from AthCnvSvc.

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

converter()

IConverter * AthCnvSvc::converter ( const CLID &  wanted )

virtualinherited

Retrieve converter from list.

Definition at line 394 of file AthCnvSvc.cxx.

{
  std::lock_guard<CallMutex> lock(m_conv_mut);
  Workers::iterator worker = m_workers.find (clid);
  if ( worker != m_workers.end() ) {
    return worker->second.converter();
  }
  if (addConverter (clid).isSuccess()) {
    worker = m_workers.find (clid);
    if (worker != m_workers.end()) {
      return worker->second.converter();
    }
  } else {
    ATH_MSG_INFO("problem adding converter for CLID [" << clid << "]");
  }
  return 0;
}

createAddress() [1/2]

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

virtual

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.

Reimplemented from AthCnvSvc.

Definition at line 964 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  )

virtual

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.

Reimplemented from AthCnvSvc.

Definition at line 906 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);
      }
   }
   Token* token = nullptr;
   if (par[0].compare(0, 3, "SHM") == 0) {
      token = new 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 = new Token();
      token->fromString(static_cast<const char*>(buffer)); buffer = nullptr;
      if (token->classID() == Guid::null()) {
         delete token; token = nullptr;
      }
      m_inputStreamingTool->getObject(&buffer, nbytes).ignore();
   } else {
      token = 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, token);
   return(StatusCode::SUCCESS);
}

createConverter()

IConverter * AthCnvSvc::createConverter ( long  typ, const CLID &  clid, const ICnvFactory *  fac  )

protectedvirtualinherited

Create new Converter using factory.

Reimplemented in Athena::NtupleCnvSvc, Athena::xAODCnvSvc, and Athena::RootCnvSvc.

Definition at line 491 of file AthCnvSvc.cxx.

{
 
  std::unique_ptr<IConverter> cnv{Converter::Factory::create
    (ConverterID(typ,clid), serviceLocator().get() )};
 
  if (!cnv) {
    typ = (typ<0xFF) ? typ : typ&0xFFFFFF00;
    cnv = Converter::Factory::create
      (ConverterID(typ,clid), serviceLocator().get() );
  }
  return cnv.release();
 
}

createObj()

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

virtual

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.

Reimplemented from AthCnvSvc.

Definition at line 192 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  )

virtual

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.

Reimplemented from AthCnvSvc.

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

dataProvider()

SmartIF< IDataProviderSvc > & AthCnvSvc::dataProvider ( ) const

virtualinherited

Implementation of IConverter: Get Data provider service.

Returns

Pointer to data provider service

Definition at line 212 of file AthCnvSvc.cxx.

{
  // FIXME: Ideally the return type should be const, but that would require
  //        changes in the Gaudi IConverter base class.
  SmartIF<IDataProviderSvc>& svc ATLAS_THREAD_SAFE =
    const_cast<SmartIF<IDataProviderSvc>&>(m_dataSvc);
  return svc;
}

decodeOutputSpec()

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

virtual

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

Implements IAthenaPoolCnvSvc.

Definition at line 989 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 )

virtual

Disconnect to the output connection.

Reimplemented from AthCnvSvc.

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

fillObjRefs()

StatusCode AthCnvSvc::fillObjRefs ( IOpaqueAddress *  pAddress, DataObject *  pObject  )

virtualinherited

Implementation of IConverter: Resolve the references of the created transient object.

Definition at line 281 of file AthCnvSvc.cxx.

{
  return makeCall (FILL_OBJ_REFS, false, true, true, pAddress, pObject);
}

fillRepRefs()

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

virtual

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.

Reimplemented from AthCnvSvc.

Definition at line 259 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 ( )

virtual

Required of all Gaudi Services.

Reimplemented from AthCnvSvc.

Definition at line 132 of file AthenaPoolCnvSvc.cxx.

                                      {
   // 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);
}

getPoolSvc()

IPoolSvc * AthenaPoolCnvSvc::getPoolSvc ( )

virtual

Returns

pointer to PoolSvc instance.

Implements IAthenaPoolCnvSvc.

Definition at line 706 of file AthenaPoolCnvSvc.cxx.

                                       {
   return(&*m_poolSvc);
}

handle()

void AthenaPoolCnvSvc::handle

(

const Incident &

incident

)

Implementation of IIncidentListener: Handle for EndEvent incidence.

Definition at line 1204 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 ( )

virtual

Required of all Gaudi Services.

Reimplemented from AthCnvSvc.

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);
}

initializeConverter()

StatusCode AthCnvSvc::initializeConverter ( long  typ, const CLID &  clid, IConverter *  cnv  )

protectedvirtualinherited

Initialize the new converter.

Definition at line 525 of file AthCnvSvc.cxx.

{
  if (cnv) {
    return cnv->initialize();
  }
  return Status::NO_CONVERTER;
}

interfaceID()

static const InterfaceID& IAthenaPoolCnvSvc::interfaceID ( )

inlinestaticinherited

Retrieve interface ID.

Definition at line 39 of file IAthenaPoolCnvSvc.h.

{ return(IID_IAthenaPoolCnvSvc); }

io_finalize()

StatusCode AthenaPoolCnvSvc::io_finalize

(

)

Definition at line 176 of file AthenaPoolCnvSvc.cxx.

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

io_reinit()

StatusCode AthenaPoolCnvSvc::io_reinit

(

)

Definition at line 126 of file AthenaPoolCnvSvc.cxx.

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

loadConverter()

void AthCnvSvc::loadConverter ( DataObject *  pObject )

protectedvirtualinherited

Load converter or dictionary needed by the converter.

Definition at line 547 of file AthCnvSvc.cxx.

{
}

makeCall()

StatusCode AthCnvSvc::makeCall ( int  typ, bool  ignore_add, bool  ignore_obj, bool  update, IOpaqueAddress *&  pAddress, DataObject *&  pObject  )

protectedinherited

Definition at line 553 of file AthCnvSvc.cxx.

{
  if ( 0 != pAddress || ignore_add )    {
    if ( 0 != pObject  || ignore_obj )    {
      const CLID&  obj_class =
        (0 != pObject && !ignore_obj) ? pObject->clID() 
        : (0 != pAddress && !ignore_add)
        ? pAddress->clID()                       
        : CLID_NULL;
      IConverter*  cnv  = converter(obj_class);
      if ( !cnv && pObject ) {
        //Give it a try to autoload the class (dictionary) for which the converter is needed
        loadConverter( pObject);
        cnv  = converter(obj_class);
      }
      
      StatusCode status(StatusCode::FAILURE);
      if ( 0 != cnv )   {
        switch(typ)   {
        case CREATE_OBJ:
          status = cnv->createObj(pAddress, pObject);
          break;
        case FILL_OBJ_REFS:
          status = cnv->fillObjRefs(pAddress, pObject);
          break;
        case UPDATE_OBJ:
          status = cnv->updateObj(pAddress, pObject);
          break;
        case UPDATE_OBJ_REFS:
          status = cnv->updateObjRefs(pAddress, pObject);
          break;
        case CREATE_REP:
          status = cnv->createRep(pObject, pAddress);
          break;
        case FILL_REP_REFS:
          status = cnv->fillRepRefs(pAddress, pObject);
          break;
        case UPDATE_REP:
          status = cnv->updateRep(pAddress, pObject);
          break;
        case UPDATE_REP_REFS:
          status = cnv->updateRepRefs(pAddress, pObject);
          break;
        default:
          status = StatusCode::FAILURE;
          break;
        }
        if ( status.isSuccess() && update )   {
          status = updateServiceState(pAddress);
        }
        return status;
      }
      status.ignore();
      msg(MSG::INFO) << "No converter for object ";
      if ( pObject != 0 )   {
        msg(MSG::INFO) << System::typeinfoName(typeid(*pObject));
      }
      msg(MSG::INFO) << "  CLID= " << obj_class << endmsg;
      return Status::NO_CONVERTER;
    }
    return Status::INVALID_OBJECT;
  }
  return Status::INVALID_ADDRESS;
}

makeClient()

StatusCode AthenaPoolCnvSvc::makeClient ( int  num )

virtual

Make this a client.

Implements IDataShare.

Definition at line 1084 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 )

virtual

Make this a server.

Implements IDataShare.

Definition at line 1058 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, ""));
}

msg() [1/2]

MsgStream& AthCommonMsg< Service >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msg() [2/2]

MsgStream& AthCommonMsg< Service >::msg ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 27 of file AthCommonMsg.h.

                                                  {
    return this->msgStream(lvl);
  }

msgLvl()

bool AthCommonMsg< Service >::msgLvl ( const MSG::Level  lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

objType()

const CLID & AthCnvSvc::objType ( ) const

inherited

Implementation of IConverter: dummy call.

Definition at line 179 of file AthCnvSvc.cxx.

{
  return CLID_NULL;
}

outputContextId()

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

private

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

queryInterface()

StatusCode AthenaPoolCnvSvc::queryInterface ( const InterfaceID &  riid, void **  ppvInterface  )

virtual

Required of all Gaudi services: see Gaudi documentation for details.

Reimplemented from AthCnvSvc.

Definition at line 181 of file AthenaPoolCnvSvc.cxx.

                                                                                        {
   if (IAthenaPoolCnvSvc::interfaceID().versionMatch(riid)) {
      *ppvInterface = dynamic_cast<IAthenaPoolCnvSvc*>(this);
   } else {
      // Interface is not directly available: try out a base class
      return(::AthCnvSvc::queryInterface(riid, ppvInterface));
   }
   addRef();
   return(StatusCode::SUCCESS);
}

readData()

StatusCode AthenaPoolCnvSvc::readData ( )

virtual

Read the next data object.

Implements IDataShare.

Definition at line 1105 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 )

virtual

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

Implements IAthenaPoolCnvSvc.

Definition at line 1011 of file AthenaPoolCnvSvc.cxx.

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

registerForWrite()

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

virtual

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.

Implements IAthenaPoolCnvSvc.

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

removeConverter()

StatusCode AthCnvSvc::removeConverter ( const CLID &  clid )

virtualinherited

Remove converter object from conversion service (if present).

Definition at line 379 of file AthCnvSvc.cxx.

{
  Workers::iterator worker = m_workers.find (clid);
  if ( worker != m_workers.end() ) {
    worker->second.converter()->finalize().ignore();
    worker->second.converter()->release();
 
    m_workers.erase (worker);
    return StatusCode::SUCCESS;
  }
  return Status::NO_CONVERTER;
}

repSvcType()

long AthCnvSvc::repSvcType ( ) const

virtualinherited

Retrieve the class type of the data store the converter uses.

Definition at line 172 of file AthCnvSvc.cxx.

{
  return m_type;
}

setAddressCreator()

StatusCode AthCnvSvc::setAddressCreator ( IAddressCreator *  creator )

virtualinherited

Set address creator facility.

Definition at line 243 of file AthCnvSvc.cxx.

{
  m_addressCreator = creator;
  Workers::iterator stop  = m_workers.end();
  Workers::iterator start = m_workers.begin();
  for(Workers::iterator i=start; i != stop; ++i )    {
    IConverter* cnv = i->second.converter();
    if ( 0 != cnv )   {
      if (cnv->setAddressCreator(m_addressCreator).isFailure()) {
        ATH_MSG_ERROR ("setting Address Creator");
      }
    }
  }
  return StatusCode::SUCCESS;
}

setConversionSvc()

StatusCode AthCnvSvc::setConversionSvc ( IConversionSvc *  svc )

virtualinherited

Implementation of IConverter: Set conversion service the converter is connected to.

Definition at line 224 of file AthCnvSvc.cxx.

{
  return StatusCode::FAILURE;
}

setDataProvider()

StatusCode AthCnvSvc::setDataProvider ( IDataProviderSvc *  pDataSvc )

virtualinherited

Implementation of IConverter: Set Data provider service.

Returns

Status code indicating success or failure

Parameters

pService

Pointer to data provider service

Definition at line 189 of file AthCnvSvc.cxx.

{
  if ( !pDataSvc ) return StatusCode::SUCCESS; //Atlas does not use DataSvc
  if ( m_dataSvc ) m_dataSvc->release();
  m_dataSvc = pDataSvc;
  m_dataSvc->addRef();
  Workers::iterator stop  = m_workers.end();
  Workers::iterator start = m_workers.begin();
  for(Workers::iterator i=start; i != stop; ++i )    {
    IConverter* cnv = i->second.converter();
    if ( 0 != cnv )   {
      if (cnv->setDataProvider(m_dataSvc).isFailure()) {
        ATH_MSG_ERROR ("setting Data Provider");
      }
    }
  }
  return StatusCode::SUCCESS;
}

setInputAttributes()

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

virtual

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

Parameters

fileName

[IN] name of the input file

Implements IAthenaPoolCnvSvc.

Definition at line 1037 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  )

virtual

Parameters

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

Implements IAthenaPoolCnvSvc.

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

updateObj()

StatusCode AthCnvSvc::updateObj ( IOpaqueAddress *  pAddress, DataObject *  refpObject  )

virtualinherited

Implementation of IConverter: Update the transient object from the other representation.

Definition at line 289 of file AthCnvSvc.cxx.

{
  return makeCall (UPDATE_OBJ, false, true, false, pAddress, pObject);
}

updateObjRefs()

StatusCode AthCnvSvc::updateObjRefs ( IOpaqueAddress *  pAddress, DataObject *  pObject  )

virtualinherited

Implementation of IConverter: Update the references of an updated transient object.

Definition at line 297 of file AthCnvSvc.cxx.

{
  return makeCall (UPDATE_OBJ_REFS, false, true, true, pAddress, pObject);
}

updateRep()

StatusCode AthCnvSvc::updateRep ( IOpaqueAddress *  pAddress, DataObject *  pObject  )

virtualinherited

Implementation of IConverter: Update the converted representation of a transient object.

Definition at line 321 of file AthCnvSvc.cxx.

{
  return makeCall (UPDATE_REP, true, false, false, pAddress, pObject);
}

updateRepRefs()

StatusCode AthCnvSvc::updateRepRefs ( IOpaqueAddress *  pAddress, DataObject *  pObject  )

virtualinherited

Implementation of IConverter: Update the references of an already converted object.

Definition at line 329 of file AthCnvSvc.cxx.

{
  return makeCall (UPDATE_REP_REFS, true, false, false, pAddress, pObject);
}

updateServiceState()

StatusCode AthCnvSvc::updateServiceState ( IOpaqueAddress *  pAddress )

virtualinherited

Update state of the service.

Reimplemented in ByteStreamCnvSvcBase, Athena::RootCnvSvc, Athena::NtupleCnvSvc, Athena::xAODCnvSvc, and MuonCalibStreamCnvSvc.

Definition at line 479 of file AthCnvSvc.cxx.

{
  return StatusCode::SUCCESS;
}

useDetailChronoStat()

bool AthenaPoolCnvSvc::useDetailChronoStat ( ) const

virtual

Returns

a boolean for using detailed time and size statistics.

Implements IAthenaPoolCnvSvc.

Definition at line 902 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_addressCreator

SmartIF<IAddressCreator> AthCnvSvc::m_addressCreator

protectedinherited

Pointer to the address creation service interface.

Definition at line 315 of file AthCnvSvc.h.

m_branchNameHintProp

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

private

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

Definition at line 216 of file AthenaPoolCnvSvc.h.

m_chronoMap

PMonUtils::BasicStopWatchResultMap_t AthenaPoolCnvSvc::m_chronoMap {}

private

Map that holds chrono information.

Definition at line 201 of file AthenaPoolCnvSvc.h.

m_clidSvc

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

private

Definition at line 193 of file AthenaPoolCnvSvc.h.

m_cnvs

std::vector<IAthenaPoolCleanUp*> IAthenaPoolCleanUpSvc::m_cnvs

protectedinherited

Definition at line 35 of file IAthenaPoolCleanUpSvc.h.

m_cnvSvc

SmartIF<IConversionSvc> AthCnvSvc::m_cnvSvc

protectedinherited

Pointer to the IConversionSvc interface of this.

Definition at line 317 of file AthCnvSvc.h.

m_containerAttr

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

private

Definition at line 222 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 214 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 212 of file AthenaPoolCnvSvc.h.

m_contextAttr

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

private

Definition at line 223 of file AthenaPoolCnvSvc.h.

m_conv_mut

CallMutex AthCnvSvc::m_conv_mut

protectedinherited

Definition at line 324 of file AthCnvSvc.h.

m_databaseAttr

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

private

Definition at line 221 of file AthenaPoolCnvSvc.h.

m_databaseMaxFileSize

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

private

Definition at line 237 of file AthenaPoolCnvSvc.h.

m_dataSvc

SmartIF<IDataProviderSvc> AthCnvSvc::m_dataSvc

protectedinherited

Pointer to data provider service.

Definition at line 313 of file AthCnvSvc.h.

m_dbType

pool::DbType AthenaPoolCnvSvc::m_dbType

private

decoded storage tech requested in "StorageTechnology" property

Definition at line 190 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 268 of file AthenaPoolCnvSvc.h.

m_DHFormCacheSize

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

private

Property for DataHeaderCnv input DHForm cache size.

Definition at line 266 of file AthenaPoolCnvSvc.h.

m_domainAttr

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

private

Definition at line 220 of file AthenaPoolCnvSvc.h.

m_domainMaxFileSize

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

private

Definition at line 236 of file AthenaPoolCnvSvc.h.

m_fileCommitCounter

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

private

Definition at line 224 of file AthenaPoolCnvSvc.h.

m_fileFlushSetting

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

private

Definition at line 225 of file AthenaPoolCnvSvc.h.

m_inputAttr

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

private

Definition at line 228 of file AthenaPoolCnvSvc.h.

m_inputAttrPerEvent

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

private

Definition at line 232 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 227 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 231 of file AthenaPoolCnvSvc.h.

m_inputStreamingTool

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

private

Definition at line 195 of file AthenaPoolCnvSvc.h.

m_lastInputFileName

std::string AthenaPoolCnvSvc::m_lastInputFileName

private

Definition at line 191 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 255 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 235 of file AthenaPoolCnvSvc.h.

m_metadataClient

int AthenaPoolCnvSvc::m_metadataClient =0

private

Definition at line 198 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 251 of file AthenaPoolCnvSvc.h.

m_metadataContainersAug

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

private

Definition at line 252 of file AthenaPoolCnvSvc.h.

m_mutex

std::mutex AthenaPoolCnvSvc::m_mutex

private

Definition at line 247 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 263 of file AthenaPoolCnvSvc.h.

m_outputStreamingTool

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

private

Definition at line 196 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 259 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 246 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 241 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 219 of file AthenaPoolCnvSvc.h.

m_poolSvc

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

private

Definition at line 192 of file AthenaPoolCnvSvc.h.

m_serializeSvc

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

private

Definition at line 194 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 209 of file AthenaPoolCnvSvc.h.

m_streamingTechnology

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

private

Use Streaming for selected technologies only.

Definition at line 257 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 261 of file AthenaPoolCnvSvc.h.

m_streamServerActive

bool AthenaPoolCnvSvc::m_streamServerActive =false

private

Definition at line 197 of file AthenaPoolCnvSvc.h.

m_type

long AthCnvSvc::m_type

protectedinherited

Conversion service type.

Definition at line 319 of file AthCnvSvc.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 206 of file AthenaPoolCnvSvc.h.

m_workers

Workers AthCnvSvc::m_workers

protectedinherited

List of conversion workers.

Definition at line 321 of file AthCnvSvc.h.

---

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

• AthenaPoolCnvSvc.h
• AthenaPoolCnvSvc.cxx