ATLAS Offline Software
Public Member Functions | Static Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Private Types | Private Member Functions | Private Attributes | List of all members
EvtRangeProcessor Class Referencefinalabstract

#include <EvtRangeProcessor.h>

Inheritance diagram for EvtRangeProcessor:
Collaboration diagram for EvtRangeProcessor:

Public Member Functions

 EvtRangeProcessor (const std::string &type, const std::string &name, const IInterface *parent)
 
virtual ~EvtRangeProcessor () override
 
virtual StatusCode initialize () override
 
virtual StatusCode finalize () override
 
virtual int makePool ATLAS_NOT_THREAD_SAFE (int maxevt, int nprocs, const std::string &topdir) override
 
virtual StatusCode exec ATLAS_NOT_THREAD_SAFE () override
 
virtual StatusCode wait_once ATLAS_NOT_THREAD_SAFE (pid_t &pid) override
 
virtual void reportSubprocessStatuses () override
 
virtual void subProcessLogs (std::vector< std::string > &) override
 
virtual AthenaMP::AllWorkerOutputs_ptr generateOutputReport () override
 
virtual std::unique_ptr< AthenaInterprocess::ScheduledWork > bootstrap_func () override
 
virtual std::unique_ptr< AthenaInterprocess::ScheduledWork > exec_func () override
 
virtual std::unique_ptr< AthenaInterprocess::ScheduledWork > fin_func () override
 
virtual void useFdsRegistry (std::shared_ptr< AthenaInterprocess::FdsRegistry >) override
 
virtual void setRandString (const std::string &randStr) override
 
virtual void killChildren () override
 
virtual std::unique_ptr< AthenaInterprocess::ScheduledWork > virtual operator() ATLAS_NOT_THREAD_SAFE(const AthenaInterprocess std::unique_ptr< AthenaInterprocess::ScheduledWork > bootstrap_func ()=0
 
ServiceHandle< StoreGateSvc > & evtStore ()
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & evtStore () const
 The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc. More...
 
const ServiceHandle< StoreGateSvc > & detStore () const
 The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc. More...
 
virtual StatusCode sysInitialize () override
 Perform system initialization for an algorithm. More...
 
virtual StatusCode sysStart () override
 Handle START transition. More...
 
virtual std::vector< Gaudi::DataHandle * > inputHandles () const override
 Return this algorithm's input handles. More...
 
virtual std::vector< Gaudi::DataHandle * > outputHandles () const override
 Return this algorithm's output handles. More...
 
Gaudi::Details::PropertyBase & declareProperty (Gaudi::Property< T > &t)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKey &hndl, const std::string &doc, const SG::VarHandleKeyType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleBase &hndl, const std::string &doc, const SG::VarHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, SG::VarHandleKeyArray &hndArr, const std::string &doc, const SG::VarHandleKeyArrayType &)
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc, const SG::NotHandleType &)
 Declare a new Gaudi property. More...
 
Gaudi::Details::PropertyBase * declareProperty (const std::string &name, T &property, const std::string &doc="none")
 Declare a new Gaudi property. More...
 
void updateVHKA (Gaudi::Details::PropertyBase &)
 
MsgStream & msg () const
 
MsgStream & msg (const MSG::Level lvl) const
 
bool msgLvl (const MSG::Level lvl) const
 
virtual std::unique_ptr< ScheduledWork > operator () ATLAS_NOT_THREAD_SAFE(const ScheduledWork &)=0
 

Static Public Member Functions

static const InterfaceID & interfaceID ()
 

Protected Types

enum  ESRange_Status {
  ESRANGE_SUCCESS, ESRANGE_NOTFOUND, ESRANGE_SEEKFAILED, ESRANGE_PROCFAILED,
  ESRANGE_FILENOTMADE, ESRANGE_BADINPFILE
}
 
enum  Func_Flag { FUNC_BOOTSTRAP, FUNC_EXEC, FUNC_FIN }
 

Protected Member Functions

int mapAsyncFlag ATLAS_NOT_THREAD_SAFE (Func_Flag flag, pid_t pid=0)
 
int redirectLog (const std::string &rundir, bool addTimeStamp=true)
 
int updateIoReg (const std::string &rundir)
 
std::string fmterror (int errnum)
 
int reopenFds ()
 
int handleSavedPfc (const std::filesystem::path &dest_path)
 
void waitForSignal ()
 
IEvtSelector * evtSelector ()
 
void renounceArray (SG::VarHandleKeyArray &handlesArray)
 remove all handles from I/O resolution More...
 
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > renounce (T &h)
 
void extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
 Add StoreName to extra input/output deps as needed. More...
 

Protected Attributes

int m_nprocs
 
std::string m_subprocTopDir
 
std::string m_subprocDirPrefix
 
std::string m_evtSelName
 
AthenaInterprocess::ProcessGroup * m_processGroup
 
ServiceHandle< IEventProcessor > m_evtProcessor
 
ServiceHandle< IAppMgrUI > m_appMgr
 
ServiceHandle< IFileMgr > m_fileMgr
 
ServiceHandle< IIoComponentMgr > m_ioMgr
 
SmartIF< IEvtSelector > m_evtSelector
 
std::string m_fileMgrLog
 
std::shared_ptr< AthenaInterprocess::FdsRegistry > m_fdsRegistry
 
std::string m_randStr
 
Gaudi::Property< bool > m_isPileup {this, "IsPileup", false, "Flag for configuring PileUpEventLoopMgr"}
 

Private Types

enum  ProcessState { PROC_STATE_INIT, PROC_STATE_EXEC, PROC_STATE_FIN, PROC_STATE_STOP }
 
typedef ServiceHandle< StoreGateSvc > StoreGateSvc_t
 

Private Member Functions

 EvtRangeProcessor ()
 
 EvtRangeProcessor (const EvtRangeProcessor &)
 
EvtRangeProcessor & operator= (const EvtRangeProcessor &)
 
StatusCode startProcess ATLAS_NOT_THREAD_SAFE ()
 
StatusCode setNewInputFile (const std::string &newFile)
 
void reportError (yampl::ISocket *socket, AthenaMPToolBase::ESRange_Status status)
 
int reopenFd (int fd, const std::string &name)
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
 specialization for handling Gaudi::Property<SG::VarHandleKey> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleKeyArrayType &)
 specialization for handling Gaudi::Property<SG::VarHandleKeyArray> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &hndl, const SG::VarHandleType &)
 specialization for handling Gaudi::Property<SG::VarHandleBase> More...
 
Gaudi::Details::PropertyBase & declareGaudiProperty (Gaudi::Property< T > &t, const SG::NotHandleType &)
 specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray> More...
 

Private Attributes

int m_rankId
 
int m_nEventsBeforeFork
 
int m_activeWorkers
 
std::string m_inpFile
 
ServiceHandle< IChronoStatSvc > m_chronoStatSvc
 
ServiceHandle< IIncidentSvc > m_incidentSvc
 
SmartIF< IEvtSelectorSeek > m_evtSeek
 
StringProperty m_channel2Scatterer
 
StringProperty m_channel2EvtSel
 
AthenaInterprocess::SharedQueue * m_sharedRankQueue
 
AthenaInterprocess::SharedQueue * m_sharedFailedPidQueue
 
std::map< pid_t, int > m_nProcessedEvents
 
std::deque< pid_t > m_finQueue
 
std::map< pid_t, ProcessState > m_procStates
 
bool m_debug
 
StoreGateSvc_t m_evtStore
 Pointer to StoreGate (event store by default) More...
 
StoreGateSvc_t m_detStore
 Pointer to StoreGate (detector store by default) More...
 
std::vector< SG::VarHandleKeyArray * > m_vhka
 
bool m_varHandleArraysDeclared
 

Detailed Description

Definition at line 24 of file EvtRangeProcessor.h.

Member Typedef Documentation

◆ StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t
privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Member Enumeration Documentation

◆ ESRange_Status

enum AthenaMPToolBase::ESRange_Status
protectedinherited
Enumerator
ESRANGE_SUCCESS 
ESRANGE_NOTFOUND 
ESRANGE_SEEKFAILED 
ESRANGE_PROCFAILED 
ESRANGE_FILENOTMADE 
ESRANGE_BADINPFILE 

Definition at line 56 of file AthenaMPToolBase.h.

56  {
57  ESRANGE_SUCCESS
58  , ESRANGE_NOTFOUND
59  , ESRANGE_SEEKFAILED
60  , ESRANGE_PROCFAILED
61  , ESRANGE_FILENOTMADE
62  , ESRANGE_BADINPFILE
63  };

◆ Func_Flag

enum AthenaMPToolBase::Func_Flag
protectedinherited
Enumerator
FUNC_BOOTSTRAP 
FUNC_EXEC 
FUNC_FIN 

Definition at line 65 of file AthenaMPToolBase.h.

65  {
66  FUNC_BOOTSTRAP
67  , FUNC_EXEC
68  , FUNC_FIN
69  };

◆ ProcessState

enum EvtRangeProcessor::ProcessState
private
Enumerator
PROC_STATE_INIT 
PROC_STATE_EXEC 
PROC_STATE_FIN 
PROC_STATE_STOP 

Definition at line 59 of file EvtRangeProcessor.h.

59  {
60  PROC_STATE_INIT
61  , PROC_STATE_EXEC
62  , PROC_STATE_FIN
63  , PROC_STATE_STOP
64  };

Constructor & Destructor Documentation

◆ EvtRangeProcessor() [1/3]

EvtRangeProcessor::EvtRangeProcessor ( const std::string &  type,
const std::string &  name,
const IInterface *  parent 
)

Definition at line 33 of file EvtRangeProcessor.cxx.

36  : AthenaMPToolBase(type,name,parent)
37  , m_rankId(-1)
38  , m_nEventsBeforeFork(0)
39  , m_activeWorkers(0)
40  , m_inpFile("")
41  , m_chronoStatSvc("ChronoStatSvc", name)
42  , m_incidentSvc("IncidentSvc", name)
43  , m_evtSeek(nullptr)
44  , m_channel2Scatterer("")
45  , m_channel2EvtSel("")
46  , m_sharedRankQueue(0)
47  , m_sharedFailedPidQueue(0)
48  , m_debug(false)
49 {
50  declareInterface<IAthenaMPTool>(this);
51 
52  declareProperty("EventsBeforeFork",m_nEventsBeforeFork);
53  declareProperty("Channel2Scatterer", m_channel2Scatterer);
54  declareProperty("Channel2EvtSel", m_channel2EvtSel);
55  declareProperty("Debug", m_debug);
56 
57  m_subprocDirPrefix = "worker_";
58 }

◆ ~EvtRangeProcessor()

EvtRangeProcessor::~EvtRangeProcessor ( )
overridevirtual

Definition at line 60 of file EvtRangeProcessor.cxx.

61 {
62 }

◆ EvtRangeProcessor() [2/3]

EvtRangeProcessor::EvtRangeProcessor ( )
private

◆ EvtRangeProcessor() [3/3]

EvtRangeProcessor::EvtRangeProcessor ( const EvtRangeProcessor &  )
private

Member Function Documentation

◆ ATLAS_NOT_THREAD_SAFE() [1/5]

StatusCode startProcess EvtRangeProcessor::ATLAS_NOT_THREAD_SAFE ( )
privatevirtual

Implements IAthenaMPTool.

◆ ATLAS_NOT_THREAD_SAFE() [2/5]

virtual StatusCode exec EvtRangeProcessor::ATLAS_NOT_THREAD_SAFE ( )
overridevirtual

Implements IAthenaMPTool.

◆ ATLAS_NOT_THREAD_SAFE() [3/5]

int mapAsyncFlag AthenaMPToolBase::ATLAS_NOT_THREAD_SAFE ( Func_Flag  flag,
pid_t  pid = 0 
)
protectedinherited

◆ ATLAS_NOT_THREAD_SAFE() [4/5]

virtual int makePool EvtRangeProcessor::ATLAS_NOT_THREAD_SAFE ( int  maxevt,
int  nprocs,
const std::string &  topdir 
)
overridevirtual

Implements IAthenaMPTool.

◆ ATLAS_NOT_THREAD_SAFE() [5/5]

virtual StatusCode wait_once EvtRangeProcessor::ATLAS_NOT_THREAD_SAFE ( pid_t &  pid)
overridevirtual

Reimplemented from AthenaMPToolBase.

◆ bootstrap_func() [1/2]

std::unique_ptr< AthenaInterprocess::ScheduledWork > EvtRangeProcessor::bootstrap_func ( )
overridevirtual

Definition at line 380 of file EvtRangeProcessor.cxx.

381 {
382  if(m_debug) waitForSignal();
383 
384  std::unique_ptr<AthenaInterprocess::ScheduledWork> outwork(new AthenaInterprocess::ScheduledWork);
385  outwork->data = malloc(sizeof(int));
386  *(int*)(outwork->data) = 1; // Error code: for now use 0 success, 1 failure
387  outwork->size = sizeof(int);
388  // ...
389  // (possible) TODO: extend outwork with some error message, which will be eventually
390  // reported in the master proces
391  // ...
392 
393  // ________________________ Get RankID ________________________
394  //
395  if(!m_sharedRankQueue->receive_basic<int>(m_rankId)) {
396  ATH_MSG_ERROR("Unable to get rank ID!");
397  return outwork;
398  }
399  std::ostringstream workindex;
400  workindex<<m_rankId;
401 
402  // ________________________ Worker dir: mkdir ________________________
403  std::filesystem::path worker_rundir(m_subprocTopDir);
404  worker_rundir /= std::filesystem::path(m_subprocDirPrefix+workindex.str());
405  // TODO: this "worker_" can be made configurable too
406 
407  if(mkdir(worker_rundir.string().c_str(),S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)==-1) {
408  ATH_MSG_ERROR("Unable to make worker run directory: " << worker_rundir.string() << ". " << fmterror(errno));
409  return outwork;
410  }
411 
412  // ________________________ Redirect logs ________________________
413  if(!m_debug) {
414  if(redirectLog(worker_rundir.string()))
415  return outwork;
416 
417  ATH_MSG_INFO("Logs redirected in the AthenaMP event worker PID=" << getpid());
418  }
419 
420  // ________________________ Update Io Registry ____________________________
421  if(updateIoReg(worker_rundir.string()))
422  return outwork;
423 
424  ATH_MSG_INFO("Io registry updated in the AthenaMP event worker PID=" << getpid());
425 
426  // ________________________ SimParams & DigiParams & PDGTABLE.MeV ____________________________
427  std::filesystem::path abs_worker_rundir = std::filesystem::absolute(worker_rundir);
428  if(std::filesystem::is_regular_file("SimParams.db"))
429  COPY_FILE_HACK("SimParams.db", abs_worker_rundir.string()+"/SimParams.db");
430  if(std::filesystem::is_regular_file("DigitParams.db"))
431  COPY_FILE_HACK("DigitParams.db", abs_worker_rundir.string()+"/DigitParams.db");
432  if(std::filesystem::is_regular_file("PDGTABLE.MeV"))
433  COPY_FILE_HACK("PDGTABLE.MeV", abs_worker_rundir.string()+"/PDGTABLE.MeV");
434 
435  // _______________________ Handle saved PFC (if any) ______________________
436  if(handleSavedPfc(abs_worker_rundir))
437  return outwork;
438 
439  // ________________________ reopen descriptors ____________________________
440  if(reopenFds())
441  return outwork;
442 
443  ATH_MSG_INFO("File descriptors re-opened in the AthenaMP event worker PID=" << getpid());
444 
445 
446  // ________________________ I/O reinit ________________________
447  if(!m_ioMgr->io_reinitialize().isSuccess()) {
448  ATH_MSG_ERROR("Failed to reinitialize I/O");
449  return outwork;
450  } else {
451  ATH_MSG_DEBUG("Successfully reinitialized I/O");
452  }
453 
454  // ________________________ Event selector restart ________________________
455  IService* evtSelSvc = dynamic_cast<IService*>(evtSelector());
456  if(!evtSelSvc) {
457  ATH_MSG_ERROR("Failed to dyncast event selector to IService");
458  return outwork;
459  }
460  if(!evtSelSvc->start().isSuccess()) {
461  ATH_MSG_ERROR("Failed to restart the event selector");
462  return outwork;
463  } else {
464  ATH_MSG_DEBUG("Successfully restarted the event selector");
465  }
466 
467  // ________________________ Restart background event selectors in pileup jobs ________________________
468  if(m_isPileup) {
469  const std::list<IService*>& service_list = serviceLocator()->getServices();
470  std::list<IService*>::const_iterator itSvc = service_list.begin(),
471  itSvcLast = service_list.end();
472  for(;itSvc!=itSvcLast;++itSvc) {
473  IEvtSelector* evtsel = dynamic_cast<IEvtSelector*>(*itSvc);
474  if(evtsel && (evtsel != evtSelector())) {
475  if((*itSvc)->start().isSuccess())
476  ATH_MSG_DEBUG("Restarted event selector " << (*itSvc)->name());
477  else {
478  ATH_MSG_ERROR("Failed to restart event selector " << (*itSvc)->name());
479  return outwork;
480  }
481  }
482  }
483  }
484 
485  // ________________________ Worker dir: chdir ________________________
486  if(chdir(worker_rundir.string().c_str())==-1) {
487  ATH_MSG_ERROR("Failed to chdir to " << worker_rundir.string());
488  return outwork;
489  }
490 
491  // Declare success and return
492  *(int*)(outwork->data) = 0;
493  return outwork;
494 }

◆ bootstrap_func() [2/2]

virtual std::unique_ptr<AthenaInterprocess::ScheduledWork> virtual operator () ATLAS_NOT_THREAD_SAFE ( const AthenaInterprocess std::unique_ptr<AthenaInterprocess::ScheduledWork> AthenaMPToolBase::bootstrap_func ( )
pure virtualinherited

◆ declareGaudiProperty() [1/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyArrayType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKeyArray>

Definition at line 170 of file AthCommonDataStore.h.

172  {
173  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
174  hndl.value(),
175  hndl.documentation());
176 
177  }

◆ declareGaudiProperty() [2/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleKeyType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

158  {
159  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
160  hndl.value(),
161  hndl.documentation());
162 
163  }

◆ declareGaudiProperty() [3/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  hndl,
const SG::VarHandleType &   
)
inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleBase>

Definition at line 184 of file AthCommonDataStore.h.

186  {
187  return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
188  hndl.value(),
189  hndl.documentation());
190  }

◆ declareGaudiProperty() [4/4]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T > &  t,
const SG::NotHandleType &   
)
inlineprivateinherited

specialization for handling everything that's not a Gaudi::Property<SG::VarHandleKey> or a <SG::VarHandleKeyArray>

Definition at line 199 of file AthCommonDataStore.h.

200  {
201  return PBASE::declareProperty(t);
202  }

◆ declareProperty() [1/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleBase &  hndl,
const std::string &  doc,
const SG::VarHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleBase. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 245 of file AthCommonDataStore.h.

249  {
250  this->declare(hndl.vhKey());
251  hndl.vhKey().setOwner(this);
252 
253  return PBASE::declareProperty(name,hndl,doc);
254  }

◆ declareProperty() [2/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKey &  hndl,
const std::string &  doc,
const SG::VarHandleKeyType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
hndlObject holding the property value.
docDocumentation string for the property.

This is the version for types that derive from SG::VarHandleKey. The property value object is put on the input and output lists as appropriate; then we forward to the base class.

Definition at line 221 of file AthCommonDataStore.h.

225  {
226  this->declare(hndl);
227  hndl.setOwner(this);
228 
229  return PBASE::declareProperty(name,hndl,doc);
230  }

◆ declareProperty() [3/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
SG::VarHandleKeyArray &  hndArr,
const std::string &  doc,
const SG::VarHandleKeyArrayType &   
)
inlineinherited

Definition at line 259 of file AthCommonDataStore.h.

263  {
264 
265  // std::ostringstream ost;
266  // ost << Algorithm::name() << " VHKA declareProp: " << name
267  // << " size: " << hndArr.keys().size()
268  // << " mode: " << hndArr.mode()
269  // << " vhka size: " << m_vhka.size()
270  // << "\n";
271  // debug() << ost.str() << endmsg;
272 
273  hndArr.setOwner(this);
274  m_vhka.push_back(&hndArr);
275 
276  Gaudi::Details::PropertyBase* p = PBASE::declareProperty(name, hndArr, doc);
277  if (p != 0) {
278  p->declareUpdateHandler(&AthCommonDataStore<PBASE>::updateVHKA, this);
279  } else {
280  ATH_MSG_ERROR("unable to call declareProperty on VarHandleKeyArray "
281  << name);
282  }
283 
284  return p;
285 
286  }

◆ declareProperty() [4/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc,
const SG::NotHandleType &   
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This is the generic version, for types that do not derive from SG::VarHandleKey. It just forwards to the base class version of declareProperty.

Definition at line 333 of file AthCommonDataStore.h.

337  {
338  return PBASE::declareProperty(name, property, doc);
339  }

◆ declareProperty() [5/6]

Gaudi::Details::PropertyBase* AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( const std::string &  name,
T &  property,
const std::string &  doc = "none" 
)
inlineinherited

Declare a new Gaudi property.

Parameters
nameName of the property.
propertyObject holding the property value.
docDocumentation string for the property.

This dispatches to either the generic declareProperty or the one for VarHandle/Key/KeyArray.

Definition at line 352 of file AthCommonDataStore.h.

355  {
356  typedef typename SG::HandleClassifier<T>::type htype;
357  return declareProperty (name, property, doc, htype());
358  }

◆ declareProperty() [6/6]

Gaudi::Details::PropertyBase& AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T > &  t)
inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

145  {
146  typedef typename SG::HandleClassifier<T>::type htype;
147  return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
148  }

◆ detStore()

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const
inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

95 { return m_detStore; }

◆ evtSelector()

IEvtSelector* AthenaMPToolBase::evtSelector ( )
inlineprotectedinherited

Definition at line 81 of file AthenaMPToolBase.h.

81 { return m_evtSelector; }

◆ evtStore() [1/2]

ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

85 { return m_evtStore; }

◆ evtStore() [2/2]

const ServiceHandle<StoreGateSvc>& AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( ) const
inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 90 of file AthCommonDataStore.h.

90 { return m_evtStore; }

◆ exec_func()

std::unique_ptr< AthenaInterprocess::ScheduledWork > EvtRangeProcessor::exec_func ( )
overridevirtual

Implements AthenaMPToolBase.

Definition at line 496 of file EvtRangeProcessor.cxx.

497 {
498  ATH_MSG_INFO("Exec function in the AthenaMP worker PID=" << getpid());
499 
500  int nEvt(1);
501  int nEventsProcessed(0);
502 
503  std::queue<std::string> queueTokens;
504 
505  // Get the yampl connection channels
506  yampl::ISocketFactory* socketFactory = new yampl::SocketFactory();
507  std::string socket2ScattererName = m_channel2Scatterer.value() + std::string("_") + m_randStr;
508  yampl::ISocket* socket2Scatterer = socketFactory->createClientSocket(yampl::Channel(socket2ScattererName,yampl::LOCAL),yampl::MOVE_DATA);
509  ATH_MSG_INFO("Created CLIENT socket to the Scatterer: " << socket2ScattererName);
510  std::ostringstream pidstr;
511  pidstr << getpid();
512 
513  // Construct a "welcome" message to be sent to the EvtRangeScatterer
514  std::string ping = pidstr.str() + std::string(" ready for event processing");
515 
516  while(true) {
517  void* message2scatterer = malloc(ping.size());
518  memcpy(message2scatterer,ping.data(),ping.size());
519  socket2Scatterer->send(message2scatterer,ping.size());
520  ATH_MSG_INFO("Sent a welcome message to the Scatterer");
521 
522  // Get the response - list of tokens - from the scatterer.
523  // The format of the response: | ResponseSize | RangeID, | evtEvtRange[,evtToken] |
524  char *responseBuffer(0);
525  std::string strPeerId;
526  ssize_t responseSize = socket2Scatterer->recv(responseBuffer,strPeerId);
527  // If response size is 0 then break the loop
528  if(responseSize==1) {
529  ATH_MSG_INFO("Empty range received. Terminating the loop");
530  break;
531  }
532 
533  std::string responseStr(responseBuffer,responseSize);
534  ATH_MSG_INFO("Received response from the Scatterer : " << responseStr);
535 
536  // Start timing
537  System::ProcessTime time_start = System::getProcessTime();
538 
539  size_t startpos(0);
540  size_t endpos = responseStr.find(',');
541  while(endpos!=std::string::npos) {
542  queueTokens.push(responseStr.substr(startpos,endpos-startpos));
543  startpos = endpos+1;
544  endpos = responseStr.find(',',startpos);
545  }
546  queueTokens.push(responseStr.substr(startpos));
547  // Actually the first element in the tokens queue is the RangeID. Get it
548  std::string rangeID = queueTokens.front();
549  queueTokens.pop();
550  ATH_MSG_INFO("Received RangeID=" << rangeID);
551  // Fire an incident
552  m_incidentSvc->fireIncident(FileIncident(name(),"NextEventRange",rangeID));
553 
554  // Here we need to support two formats of the responseStr
555  // Format 1. RangeID,startEvent,endEvent
556  // Format 2. RangeID,fileName,startEvent,endEvent
557  //
558  // The difference between these two is that for Format 2 we first
559  // need to update InputCollections property on the Event Selector
560  // and only after that proceed with seeking
561  //
562  // The seeking part is identical for Format 1 and 2
563 
564  AthenaMPToolBase::ESRange_Status rangeStatus(AthenaMPToolBase::ESRANGE_SUCCESS);
565 
566  // Determine the format
567  std::string filename("");
568  if(queueTokens.front().find("PFN:")==0) {
569  // We have Format 2
570  // Update InputCollections property of the Event Selector with the file name from Event Range
571  filename = queueTokens.front().substr(4);
572  if(setNewInputFile(filename).isFailure()) {
573  ATH_MSG_WARNING("Failed to set input file for the range: " << rangeID);
574  rangeStatus = AthenaMPToolBase::ESRANGE_BADINPFILE;
575  reportError(socket2Scatterer,rangeStatus);
576  m_incidentSvc->fireIncident(FileIncident(name(),"NextEventRange","dummy"));
577  continue;
578  }
579  queueTokens.pop();
580  }
581 
582  // Get the number of events to process
583  int startEvent = std::atoi(queueTokens.front().c_str());
584  queueTokens.pop();
585  int endEvent = std::atoi(queueTokens.front().c_str());
586  queueTokens.pop();
587  ATH_MSG_INFO("Range fields. File Name: " << (filename.empty()?"N/A":filename)
588  << ", First Event:" << startEvent
589  << ", Last Event:" << endEvent);
590 
591  // Process the events
592  IEvtSelector::Context* ctx = nullptr;
593  if (evtSelector()->createContext (ctx).isFailure()) {
594  ATH_MSG_WARNING("Failed to create IEventSelector context.");
595  rangeStatus = AthenaMPToolBase::ESRANGE_SEEKFAILED;
596  }
597  else {
598  for(int i(startEvent-1); i<endEvent; ++i) {
599  StatusCode sc = m_evtSeek->seek(*ctx, i);
600  if(sc.isRecoverable()) {
601  ATH_MSG_WARNING("Event " << i << " from range: " << rangeID << " not in the input file");
602  rangeStatus = AthenaMPToolBase::ESRANGE_NOTFOUND;
603  break;
604  }
605  else if(sc.isFailure()) {
606  ATH_MSG_WARNING("Failed to seek to " << i << " in range: " << rangeID);
607  rangeStatus = AthenaMPToolBase::ESRANGE_SEEKFAILED;
608  break;
609  }
610  ATH_MSG_INFO("Seek to " << i << " succeeded");
611  m_chronoStatSvc->chronoStart("AthenaMP_nextEvent");
612  sc = m_evtProcessor->nextEvent(nEvt++);
613 
614  m_chronoStatSvc->chronoStop("AthenaMP_nextEvent");
615  if(sc.isFailure()){
616  ATH_MSG_WARNING("Failed to process the event " << i << " in range:" << rangeID);
617  rangeStatus = AthenaMPToolBase::ESRANGE_PROCFAILED;
618  break;
619  }
620  else {
621  ATH_MSG_DEBUG("Event processed");
622  nEventsProcessed++;
623  }
624  }
625  }
626  if (evtSelector()->releaseContext (ctx).isFailure()) {
627  ATH_MSG_WARNING("Failed to release IEventSelector context.");
628  }
629 
630  // Fire dummy NextEventRange incident in order to cut the previous output and report it
631  m_incidentSvc->fireIncident(FileIncident(name(),"NextEventRange","dummy"));
632  if(rangeStatus!=AthenaMPToolBase::ESRANGE_SUCCESS) {
633  reportError(socket2Scatterer,rangeStatus);
634  continue;
635  }
636 
637  // Event range successfully processed
638  std::string strOutpFile;
639  // Get the full path of the event range output file
640  for(std::filesystem::directory_iterator fdIt(std::filesystem::current_path()); fdIt!=std::filesystem::directory_iterator(); fdIt++) {
641  if(fdIt->path().string().rfind(rangeID) == fdIt->path().string().size()-rangeID.size()) {
642  if(strOutpFile.empty()) {
643  strOutpFile = fdIt->path().string();
644  }
645  else {
646  strOutpFile += (std::string(",")+fdIt->path().string());
647  }
648  }
649  }
650 
651  // Stop timing
652  System::ProcessTime time_delta = System::getProcessTime() - time_start;
653 
654  // Prepare the output report
655  if(!strOutpFile.empty()) {
656  // We need to combine the output file name with
657  // 1. RangeID (requested by JEDI)
658  // 2. CPU time
659  // 3. Wall time
660  std::ostringstream outputReportStream;
661  outputReportStream << strOutpFile
662  << ",ID:" << rangeID
663  << ",CPU:" << time_delta.cpuTime<System::Sec>()
664  << ",WALL:" << time_delta.elapsedTime<System::Sec>();
665  std::string outputFileReport = outputReportStream.str();
666 
667  // Report the output
668  message2scatterer = malloc(outputFileReport.size());
669  memcpy(message2scatterer,outputFileReport.data(),outputFileReport.size());
670  socket2Scatterer->send(message2scatterer,outputFileReport.size());
671  ATH_MSG_INFO("Reported the output " << outputFileReport);
672  }
673  else {
674  // This is an error: range successfully processed but no outputs were made
675  ATH_MSG_WARNING("Failed to make an output file for range: " << rangeID);
676  reportError(socket2Scatterer,AthenaMPToolBase::ESRANGE_FILENOTMADE);
677  }
678  } // Main "event loop"
679 
680  if(m_evtProcessor->executeRun(0).isFailure()) {
681  ATH_MSG_WARNING("Could not finalize the Run");
682  }
683 
684  std::unique_ptr<AthenaInterprocess::ScheduledWork> outwork(new AthenaInterprocess::ScheduledWork);
685 
686  // Return value: "ERRCODE|Func_Flag|NEvt"
687  int outsize = 2*sizeof(int)+sizeof(AthenaMPToolBase::Func_Flag);
688  void* outdata = malloc(outsize);
689  *(int*)(outdata) = 0; // Error code: for now use 0 success, 1 failure
690  AthenaMPToolBase::Func_Flag func = AthenaMPToolBase::FUNC_EXEC;
691  memcpy((char*)outdata+sizeof(int),&func,sizeof(func));
692  memcpy((char*)outdata+sizeof(int)+sizeof(func),&nEventsProcessed,sizeof(int));
693 
694  outwork->data = outdata;
695  outwork->size = outsize;
696  // ...
697  // (possible) TODO: extend outwork with some error message, which will be eventually
698  // reported in the master proces
699  // ...
700 
701  delete socket2Scatterer;
702  delete socketFactory;
703 
704  return outwork;
705 }

◆ extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase &  ExtraDeps)
protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

◆ fin_func()

std::unique_ptr< AthenaInterprocess::ScheduledWork > EvtRangeProcessor::fin_func ( )
overridevirtual

Implements AthenaMPToolBase.

Definition at line 707 of file EvtRangeProcessor.cxx.

708 {
709  ATH_MSG_INFO("Fin function in the AthenaMP worker PID=" << getpid());
710 
711  if(m_appMgr->stop().isFailure()) {
712  ATH_MSG_WARNING("Unable to stop AppMgr");
713  }
714  else {
715  if(m_appMgr->finalize().isFailure()) {
716  std::cout << "Unable to finalize AppMgr" << std::endl;
717  }
718  }
719 
720  std::unique_ptr<AthenaInterprocess::ScheduledWork> outwork(new AthenaInterprocess::ScheduledWork);
721 
722  // Return value: "ERRCODE|Func_Flag|NEvt" (Here NEvt=-1)
723  int outsize = 2*sizeof(int)+sizeof(AthenaMPToolBase::Func_Flag);
724  void* outdata = malloc(outsize);
725  *(int*)(outdata) = 0; // Error code: for now use 0 success, 1 failure
726  AthenaMPToolBase::Func_Flag func = AthenaMPToolBase::FUNC_FIN;
727  memcpy((char*)outdata+sizeof(int),&func,sizeof(func));
728  int nEvt = -1;
729  memcpy((char*)outdata+sizeof(int)+sizeof(func),&nEvt,sizeof(int));
730 
731  outwork->data = outdata;
732  outwork->size = outsize;
733 
734  return outwork;
735 }

◆ finalize()

StatusCode EvtRangeProcessor::finalize ( )
overridevirtual

Reimplemented from AthenaMPToolBase.

Definition at line 77 of file EvtRangeProcessor.cxx.

78 {
79  delete m_sharedRankQueue;
80  return StatusCode::SUCCESS;
81 }

◆ fmterror()

std::string AthenaMPToolBase::fmterror ( int  errnum)
protectedinherited

Definition at line 358 of file AthenaMPToolBase.cxx.

359 {
360  char buf[256];
361  strerror_r(errnum, buf, sizeof(buf));
362  return std::string(buf);
363 }

◆ generateOutputReport()

AthenaMP::AllWorkerOutputs_ptr EvtRangeProcessor::generateOutputReport ( )
overridevirtual

Reimplemented from AthenaMPToolBase.

Definition at line 374 of file EvtRangeProcessor.cxx.

375 {
376  AthenaMP::AllWorkerOutputs_ptr jobOutputs(new AthenaMP::AllWorkerOutputs());
377  return jobOutputs;
378 }

◆ handleSavedPfc()

int AthenaMPToolBase::handleSavedPfc ( const std::filesystem::path &  dest_path)
protectedinherited

Definition at line 421 of file AthenaMPToolBase.cxx.

422 {
423  if(std::filesystem::is_regular_file("PoolFileCatalog.xml.AthenaMP-saved"))
424  COPY_FILE_HACK("PoolFileCatalog.xml.AthenaMP-saved",dest_path.string()+"/PoolFileCatalog.xml");
425  return 0;
426 }

◆ initialize()

StatusCode EvtRangeProcessor::initialize ( )
overridevirtual

Reimplemented from AthenaMPToolBase.

Definition at line 64 of file EvtRangeProcessor.cxx.

65 {
66  ATH_MSG_DEBUG("In initialize");
67 
68  ATH_CHECK(AthenaMPToolBase::initialize());
69  m_evtSeek = serviceLocator()->service(m_evtSelName);
70  ATH_CHECK(m_evtSeek.isValid());
71  ATH_CHECK(m_chronoStatSvc.retrieve());
72  ATH_CHECK(m_incidentSvc.retrieve());
73 
74  return StatusCode::SUCCESS;
75 }

◆ inputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const
overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ interfaceID()

static const InterfaceID& IAthenaMPTool::interfaceID ( )
inlinestaticinherited

Definition at line 36 of file IAthenaMPTool.h.

36 { return IID_IAthenaMPTool; }

◆ killChildren()

void AthenaMPToolBase::killChildren ( )
overridevirtualinherited

Implements IAthenaMPTool.

Definition at line 213 of file AthenaMPToolBase.cxx.

214 {
215  for(const AthenaInterprocess::Process& child : m_processGroup->getChildren()) {
216  kill(child.getProcessID(),SIGKILL);
217  }
218 }

◆ msg() [1/2]

MsgStream& AthCommonMsg< AlgTool >::msg ( ) const
inlineinherited

Definition at line 24 of file AthCommonMsg.h.

24  {
25  return this->msgStream();
26  }

◆ msg() [2/2]

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

Definition at line 27 of file AthCommonMsg.h.

27  {
28  return this->msgStream(lvl);
29  }

◆ msgLvl()

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

Definition at line 30 of file AthCommonMsg.h.

30  {
31  return this->msgLevel(lvl);
32  }

◆ operator()

virtual std::unique_ptr<ScheduledWork> AthenaInterprocess::IMessageDecoder::operator ( ) const &
pure virtualinherited

◆ operator=()

EvtRangeProcessor& EvtRangeProcessor::operator= ( const EvtRangeProcessor &  )
private

◆ outputHandles()

virtual std::vector<Gaudi::DataHandle*> AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const
overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

◆ redirectLog()

int AthenaMPToolBase::redirectLog ( const std::string &  rundir,
bool  addTimeStamp = true 
)
protectedinherited

Definition at line 281 of file AthenaMPToolBase.cxx.

282 {
283  // Redirect both stdout and stderr to the same file AthenaMP.log
284  int dup2result1(0), dup2result2(0);
285 
286  int newout = open(std::string(rundir+"/AthenaMP.log").c_str(),O_CREAT | O_RDWR, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH);
287  if(newout==-1) {
288  ATH_MSG_ERROR("Unable to open log file in the run directory. " << fmterror(errno));
289  return -1;
290  }
291  dup2result1 = dup2(newout, STDOUT_FILENO);
292  dup2result2 = dup2(newout, STDERR_FILENO);
293  TEMP_FAILURE_RETRY(close(newout));
294  if(dup2result1==-1) {
295  ATH_MSG_ERROR("Unable to redirect standard output. " << fmterror(errno));
296  return -1;
297  }
298  if(dup2result2==-1) {
299  ATH_MSG_ERROR("Unable to redirect standard error. " << fmterror(errno));
300  return -1;
301  }
302 
303  if(addTimeStamp) {
304  SmartIF<IProperty> propertyServer(msgSvc());
305  if(propertyServer==0) {
306  ATH_MSG_ERROR("Unable to cast message svc to IProperty");
307  return -1;
308  }
309 
310  std::string propertyName("Format");
311  std::string oldFormat("");
312  StringProperty formatProp(propertyName,oldFormat);
313  StatusCode sc = propertyServer->getProperty(&formatProp);
314  if(sc.isFailure()) {
315  ATH_MSG_WARNING("Message Service does not have Format property");
316  }
317  else {
318  oldFormat = formatProp.value();
319  if(oldFormat.find("%t")==std::string::npos) {
320  // Add time stamps
321  std::string newFormat("%t " + oldFormat);
322  StringProperty newFormatProp(propertyName,newFormat);
323  if(propertyServer->setProperty(newFormatProp).isFailure()) {
324  ATH_MSG_ERROR("Unable to set new Format property on the Message Service");
325  return -1;
326  }
327  }
328  else {
329  ATH_MSG_DEBUG("MsgSvc format already contains timestamps. Nothing to be done");
330  }
331  }
332  }
333 
334  return 0;
335 }

◆ renounce()

std::enable_if_t<std::is_void_v<std::result_of_t<decltype(&T::renounce)(T)> > && !std::is_base_of_v<SG::VarHandleKeyArray, T> && std::is_base_of_v<Gaudi::DataHandle, T>, void> AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T &  h)
inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

381  {
382  h.renounce();
383  PBASE::renounce (h);
384  }

◆ renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray &  handlesArray)
inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

364  {
365  handlesArray.renounce();
366  }

◆ reopenFd()

int AthenaMPToolBase::reopenFd ( int  fd,
const std::string &  name 
)
privateinherited

Definition at line 444 of file AthenaMPToolBase.cxx.

445 {
446  ATH_MSG_DEBUG("Attempting to reopen descriptor for " << name);
447  int old_openflags = fcntl(fd,F_GETFL,0);
448  switch(old_openflags & O_ACCMODE) {
449  case O_RDONLY: {
450  ATH_MSG_DEBUG("The File Access Mode is RDONLY");
451  break;
452  }
453  case O_WRONLY: {
454  ATH_MSG_DEBUG("The File Access Mode is WRONLY");
455  break;
456  }
457  case O_RDWR: {
458  ATH_MSG_DEBUG("The File Access Mode is RDWR");
459  break;
460  }
461  }
462 
463  int old_descflags = fcntl(fd,F_GETFD,0);
464  off_t oldpos = lseek(fd,0,SEEK_CUR);
465  if(oldpos==-1) {
466  if(errno==ESPIPE) {
467  ATH_MSG_WARNING("Dealing with PIPE. Skipping ... (FIXME!)");
468  }
469  else {
470  ATH_MSG_ERROR("When re-opening file descriptors lseek failed on " << name << ". " << fmterror(errno));
471  return -1;
472  }
473  }
474  else {
475  Io::Fd newfd = open(name.c_str(),old_openflags);
476  if(newfd==-1) {
477  ATH_MSG_ERROR("When re-opening file descriptors unable to open " << name << " for reading. " << fmterror(errno));
478  return -1;
479  }
480  if(lseek(newfd,oldpos,SEEK_SET)==-1){
481  ATH_MSG_ERROR("When re-opening file descriptors lseek failed on the newly opened " << name << ". " << fmterror(errno));
482  TEMP_FAILURE_RETRY(close(newfd));
483  return -1;
484  }
485  TEMP_FAILURE_RETRY(close(fd));
486  if(dup2(newfd,fd)==-1) {
487  ATH_MSG_ERROR("When re-opening file descriptors unable to duplicate descriptor for " << name << ". " << fmterror(errno));
488  TEMP_FAILURE_RETRY(close(newfd));
489  return -1;
490  }
491  if(fcntl(fd,F_SETFD,old_descflags)==-1) {
492  ATH_MSG_ERROR("When re-opening file descriptors unable to set descriptor flags for " << name << ". " << fmterror(errno));
493  TEMP_FAILURE_RETRY(close(newfd));
494  return -1;
495  }
496  TEMP_FAILURE_RETRY(close(newfd));
497  }
498  return 0;
499 }

◆ reopenFds()

int AthenaMPToolBase::reopenFds ( )
protectedinherited

Definition at line 365 of file AthenaMPToolBase.cxx.

366 {
367  // Reopen file descriptors.
368  // First go over all open files, which have been registered with the FileMgr
369  // Then also check the FdsRegistry, in case it contains some files not registered with the FileMgr
370  std::set<int> fdLog;
371 
372  // Query the FileMgr contents
373  std::vector<const Io::FileAttr*> filemgrFiles;
374  std::vector<const Io::FileAttr*>::const_iterator itFile;
375  unsigned filenum = m_fileMgr->getFiles(filemgrFiles); // Get attributes for open files only. We don't care about closed ones at this point
376  if(filenum!=filemgrFiles.size())
377  ATH_MSG_WARNING("getFiles returned " << filenum << " while vector size is " << filemgrFiles.size());
378 
379  for(itFile=filemgrFiles.begin();itFile!=filemgrFiles.end();++itFile) {
380  ATH_MSG_DEBUG("* " << **itFile);
381  const std::string& filename = (**itFile).name();
382  Io::Fd fd = (**itFile).fd();
383 
384  if(fd==-1) {
385  // It is legal to have fd=-1 for remote inputs
386  // On the other hand, these inputs should not remain open after fork. The issue being tracked at ATEAM-434.
387  // So, this hopefully is a temporary patch
388  ATH_MSG_WARNING("FD=-1 detected on an open file retrieved from FileMgr. Skip FD reopening. File name: " << filename);
389  continue;
390  }
391 
392  if(reopenFd(fd,filename))
393  return -1;
394 
395  fdLog.insert(fd);
396  }
397 
398  // Check the FdsRegistry
399  for(const AthenaInterprocess::FdsRegistryEntry& regEntry : *m_fdsRegistry) {
400  if(fdLog.find(regEntry.fd)!=fdLog.end()) {
401  ATH_MSG_DEBUG("The file from FdsRegistry " << regEntry.name << " was registered with FileMgr. Skip reopening");
402  }
403  else {
404  ATH_MSG_WARNING("The file " << regEntry.name << " has not been registered with the FileMgr!");
405 
406  if(regEntry.fd==-1) {
407  // Same protection as the one above
408  ATH_MSG_WARNING("FD=-1 detected on an open file retrieved from FD Registry. Skip FD reopening. File name: " << regEntry.name);
409  continue;
410  }
411 
412  if(reopenFd(regEntry.fd,regEntry.name))
413  return -1;
414 
415  fdLog.insert(regEntry.fd);
416  }
417  }
418  return 0;
419 }

◆ reportError()

void EvtRangeProcessor::reportError ( yampl::ISocket *  socket,
AthenaMPToolBase::ESRange_Status  status 
)
private

Definition at line 796 of file EvtRangeProcessor.cxx.

797 {
798  pid_t pid = getpid();
799  size_t messageSize = sizeof(pid_t)+sizeof(AthenaMPToolBase::ESRange_Status);
800  void* message2scatterer = malloc(messageSize);
801  memcpy(message2scatterer,&pid,sizeof(pid_t));
802  memcpy((pid_t*)message2scatterer+1,&status,sizeof(AthenaMPToolBase::ESRange_Status));
803  socket->send(message2scatterer,messageSize);
804 }

◆ reportSubprocessStatuses()

void EvtRangeProcessor::reportSubprocessStatuses ( )
overridevirtual

Reimplemented from AthenaMPToolBase.

Definition at line 344 of file EvtRangeProcessor.cxx.

345 {
346  ATH_MSG_INFO("Statuses of event processors");
347  const std::vector<AthenaInterprocess::ProcessStatus>& statuses = m_processGroup->getStatuses();
348  for(size_t i=0; i<statuses.size(); ++i) {
349  // Get the number of events processed by this worker
350  std::map<pid_t,int>::const_iterator it = m_nProcessedEvents.find(statuses[i].pid);
351  std::ostringstream ostr;
352  if(it==m_nProcessedEvents.end())
353  ostr << "N/A";
354  else
355  ostr << it->second;
356  ATH_MSG_INFO("*** Process PID=" << statuses[i].pid
357  << ". Status " << ((statuses[i].exitcode)?"FAILURE":"SUCCESS")
358  << ". Number of events processed: " << ostr.str());
359  }
360 }

◆ setNewInputFile()

StatusCode EvtRangeProcessor::setNewInputFile ( const std::string &  newFile)
private

Definition at line 762 of file EvtRangeProcessor.cxx.

763 {
764  if(m_inpFile == newFile) return StatusCode::SUCCESS;
765 
766  // Get Property Server
767  IProperty* propertyServer = dynamic_cast<IProperty*>(evtSelector());
768  if(!propertyServer) {
769  ATH_MSG_ERROR("Unable to dyn-cast the event selector to IProperty");
770  return StatusCode::FAILURE;
771  }
772 
773  std::string propertyName("InputCollections");
774  if(m_inpFile.empty()) {
775  std::vector<std::string> vect;
776  StringArrayProperty inputFileList(propertyName, vect);
777  if(propertyServer->getProperty(&inputFileList).isFailure()) {
778  ATH_MSG_ERROR("Failed to get InputCollections property value of the Event Selector");
779  return StatusCode::FAILURE;
780  }
781  if(newFile==inputFileList.value()[0]) {
782  m_inpFile = newFile;
783  return StatusCode::SUCCESS;
784  }
785  }
786  std::vector<std::string> vect{newFile,};
787  StringArrayProperty newInputFileList(propertyName, vect);
788  if(propertyServer->setProperty(newInputFileList).isFailure()) {
789  ATH_MSG_ERROR("Unable to update " << newInputFileList.name() << " property on the Event Selector");
790  return StatusCode::FAILURE;
791  }
792  m_inpFile=newFile;
793  return StatusCode::SUCCESS;
794 }

◆ setRandString()

void AthenaMPToolBase::setRandString ( const std::string &  randStr)
overridevirtualinherited

Implements IAthenaMPTool.

Definition at line 208 of file AthenaMPToolBase.cxx.

209 {
210  m_randStr = randStr;
211 }

◆ subProcessLogs()

void EvtRangeProcessor::subProcessLogs ( std::vector< std::string > &  filenames)
overridevirtual

Implements IAthenaMPTool.

Definition at line 362 of file EvtRangeProcessor.cxx.

363 {
364  filenames.clear();
365  for(int i=0; i<m_nprocs; ++i) {
366  std::ostringstream workerIndex;
367  workerIndex << i;
368  std::filesystem::path worker_rundir(m_subprocTopDir);
369  worker_rundir /= std::filesystem::path(m_subprocDirPrefix+workerIndex.str());
370  filenames.push_back(worker_rundir.string()+std::string("/AthenaMP.log"));
371  }
372 }

◆ sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )
overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in DerivationFramework::CfAthAlgTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and asg::AsgMetadataTool.

◆ sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )
overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

◆ updateIoReg()

int AthenaMPToolBase::updateIoReg ( const std::string &  rundir)
protectedinherited

Definition at line 337 of file AthenaMPToolBase.cxx.

338 {
339  if (!m_ioMgr.retrieve().isSuccess()) {
340  ATH_MSG_ERROR("Error retrieving IoComponentMgr");
341  return -1;
342  } else {
343  ATH_MSG_DEBUG("Successfully retrieved IoComponentMgr");
344  }
345 
346  // update the IoRegistry for the new workdir - make sure we use absolute path
347  std::filesystem::path abs_rundir = std::filesystem::absolute(rundir);
348  if(!m_ioMgr->io_update_all(abs_rundir.string()).isSuccess()) {
349  ATH_MSG_ERROR("Error updating IoRegistry");
350  return -1;
351  } else {
352  ATH_MSG_DEBUG("Successfully updated IoRegistry");
353  }
354 
355  return 0;
356 }

◆ updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase &  )
inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

308  {
309  // debug() << "updateVHKA for property " << p.name() << " " << p.toString()
310  // << " size: " << m_vhka.size() << endmsg;
311  for (auto &a : m_vhka) {
312  std::vector<SG::VarHandleKey*> keys = a->keys();
313  for (auto k : keys) {
314  k->setOwner(this);
315  }
316  }
317  }

◆ useFdsRegistry()

void AthenaMPToolBase::useFdsRegistry ( std::shared_ptr< AthenaInterprocess::FdsRegistry >  registry)
overridevirtualinherited

Implements IAthenaMPTool.

Definition at line 203 of file AthenaMPToolBase.cxx.

204 {
205  m_fdsRegistry = registry;
206 }

◆ waitForSignal()

void AthenaMPToolBase::waitForSignal ( )
protectedinherited

Definition at line 428 of file AthenaMPToolBase.cxx.

429 {
430  ATH_MSG_INFO("Bootstrap worker PID " << getpid() << " - waiting for SIGUSR1");
431  sigset_t mask, oldmask;
432 
433  signal(SIGUSR1, AthenaMPToolBase_d::pauseForDebug);
434 
435  sigemptyset (&mask);
436  sigaddset (&mask, SIGUSR1);
437 
438  sigprocmask (SIG_BLOCK, &mask, &oldmask);
439  while (!AthenaMPToolBase_d::sig_done)
440  sigsuspend (&oldmask);
441  sigprocmask (SIG_UNBLOCK, &mask, NULL);
442 }

Member Data Documentation

◆ m_activeWorkers

int EvtRangeProcessor::m_activeWorkers
private

Definition at line 68 of file EvtRangeProcessor.h.

◆ m_appMgr

ServiceHandle<IAppMgrUI> AthenaMPToolBase::m_appMgr
protectedinherited

Definition at line 91 of file AthenaMPToolBase.h.

◆ m_channel2EvtSel

StringProperty EvtRangeProcessor::m_channel2EvtSel
private

Definition at line 76 of file EvtRangeProcessor.h.

◆ m_channel2Scatterer

StringProperty EvtRangeProcessor::m_channel2Scatterer
private

Definition at line 75 of file EvtRangeProcessor.h.

◆ m_chronoStatSvc

ServiceHandle<IChronoStatSvc> EvtRangeProcessor::m_chronoStatSvc
private

Definition at line 71 of file EvtRangeProcessor.h.

◆ m_debug

bool EvtRangeProcessor::m_debug
private

Definition at line 85 of file EvtRangeProcessor.h.

◆ m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

◆ m_evtProcessor

ServiceHandle<IEventProcessor> AthenaMPToolBase::m_evtProcessor
protectedinherited

Definition at line 90 of file AthenaMPToolBase.h.

◆ m_evtSeek

SmartIF<IEvtSelectorSeek> EvtRangeProcessor::m_evtSeek
private

Definition at line 73 of file EvtRangeProcessor.h.

◆ m_evtSelector

SmartIF<IEvtSelector> AthenaMPToolBase::m_evtSelector
protectedinherited

Definition at line 94 of file AthenaMPToolBase.h.

◆ m_evtSelName

std::string AthenaMPToolBase::m_evtSelName
protectedinherited

Definition at line 86 of file AthenaMPToolBase.h.

◆ m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

◆ m_fdsRegistry

std::shared_ptr<AthenaInterprocess::FdsRegistry> AthenaMPToolBase::m_fdsRegistry
protectedinherited

Definition at line 96 of file AthenaMPToolBase.h.

◆ m_fileMgr

ServiceHandle<IFileMgr> AthenaMPToolBase::m_fileMgr
protectedinherited

Definition at line 92 of file AthenaMPToolBase.h.

◆ m_fileMgrLog

std::string AthenaMPToolBase::m_fileMgrLog
protectedinherited

Definition at line 95 of file AthenaMPToolBase.h.

◆ m_finQueue

std::deque<pid_t> EvtRangeProcessor::m_finQueue
private

Definition at line 82 of file EvtRangeProcessor.h.

◆ m_incidentSvc

ServiceHandle<IIncidentSvc> EvtRangeProcessor::m_incidentSvc
private

Definition at line 72 of file EvtRangeProcessor.h.

◆ m_inpFile

std::string EvtRangeProcessor::m_inpFile
private

Definition at line 69 of file EvtRangeProcessor.h.

◆ m_ioMgr

ServiceHandle<IIoComponentMgr> AthenaMPToolBase::m_ioMgr
protectedinherited

Definition at line 93 of file AthenaMPToolBase.h.

◆ m_isPileup

Gaudi::Property<bool> AthenaMPToolBase::m_isPileup {this, "IsPileup", false, "Flag for configuring PileUpEventLoopMgr"}
protectedinherited

Definition at line 99 of file AthenaMPToolBase.h.

◆ m_nEventsBeforeFork

int EvtRangeProcessor::m_nEventsBeforeFork
private

Definition at line 67 of file EvtRangeProcessor.h.

◆ m_nProcessedEvents

std::map<pid_t,int> EvtRangeProcessor::m_nProcessedEvents
private

Definition at line 81 of file EvtRangeProcessor.h.

◆ m_nprocs

int AthenaMPToolBase::m_nprocs
protectedinherited

Definition at line 83 of file AthenaMPToolBase.h.

◆ m_processGroup

AthenaInterprocess::ProcessGroup* AthenaMPToolBase::m_processGroup
protectedinherited

Definition at line 88 of file AthenaMPToolBase.h.

◆ m_procStates

std::map<pid_t,ProcessState> EvtRangeProcessor::m_procStates
private

Definition at line 83 of file EvtRangeProcessor.h.

◆ m_randStr

std::string AthenaMPToolBase::m_randStr
protectedinherited

Definition at line 97 of file AthenaMPToolBase.h.

◆ m_rankId

int EvtRangeProcessor::m_rankId
private

Definition at line 66 of file EvtRangeProcessor.h.

◆ m_sharedFailedPidQueue

AthenaInterprocess::SharedQueue* EvtRangeProcessor::m_sharedFailedPidQueue
private

Definition at line 79 of file EvtRangeProcessor.h.

◆ m_sharedRankQueue

AthenaInterprocess::SharedQueue* EvtRangeProcessor::m_sharedRankQueue
private

Definition at line 78 of file EvtRangeProcessor.h.

◆ m_subprocDirPrefix

std::string AthenaMPToolBase::m_subprocDirPrefix
protectedinherited

Definition at line 85 of file AthenaMPToolBase.h.

◆ m_subprocTopDir

std::string AthenaMPToolBase::m_subprocTopDir
protectedinherited

Definition at line 84 of file AthenaMPToolBase.h.

◆ m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared
privateinherited

Definition at line 399 of file AthCommonDataStore.h.

◆ m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
privateinherited

Definition at line 398 of file AthCommonDataStore.h.

The documentation for this class was generated from the following files:
python.Dso.registry
registry
Definition: Control/AthenaServices/python/Dso.py:159
python.DQPostProcessMod.rundir
def rundir(fname)
Definition: DQPostProcessMod.py:116
pid_t
int32_t pid_t
Definition: FPGATrackSimTypes.h:19
AthenaInterprocess::ProcessGroup::getStatuses
const std::vector< ProcessStatus > & getStatuses() const
Definition: ProcessGroup.cxx:204
AthenaMPToolBase::waitForSignal
void waitForSignal()
Definition: AthenaMPToolBase.cxx:428
athena.path
path
python interpreter configuration --------------------------------------—
Definition: athena.py:128
EvtRangeProcessor::m_activeWorkers
int m_activeWorkers
Definition: EvtRangeProcessor.h:68
AthenaMPToolBase::ESRANGE_BADINPFILE
@ ESRANGE_BADINPFILE
Definition: AthenaMPToolBase.h:62
ATH_MSG_INFO
#define ATH_MSG_INFO(x)
Definition: AthMsgStreamMacros.h:31
plot_material.mkdir
def mkdir(path, recursive=True)
Definition: plot_material.py:16
CaloCellPos2Ntuple.int
int
Definition: CaloCellPos2Ntuple.py:24
LArBadChanBlobUtils::Channel
Identifier32::value_type Channel
Definition: LArBadChanBlobUtils.h:24
AthenaMPToolBase::m_processGroup
AthenaInterprocess::ProcessGroup * m_processGroup
Definition: AthenaMPToolBase.h:88
AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty
Gaudi::Details::PropertyBase & declareProperty(Gaudi::Property< T > &t)
Definition: AthCommonDataStore.h:145
AthenaInterprocess::ScheduledWork
Definition: IMessageDecoder.h:12
AthenaMPToolBase::m_randStr
std::string m_randStr
Definition: AthenaMPToolBase.h:97
AthenaMPToolBase::m_nprocs
int m_nprocs
Definition: AthenaMPToolBase.h:83
AthenaMPToolBase::ESRange_Status
ESRange_Status
Definition: AthenaMPToolBase.h:56
AthenaMPToolBase::FUNC_FIN
@ FUNC_FIN
Definition: AthenaMPToolBase.h:68
AthenaInterprocess::ProcessGroup::getChildren
const std::vector< Process > & getChildren() const
Definition: ProcessGroup.cxx:197
plotting.yearwise_luminosity.absolute
absolute
Definition: yearwise_luminosity.py:29
skel.it
it
Definition: skel.GENtoEVGEN.py:396
AthenaMPToolBase::fmterror
std::string fmterror(int errnum)
Definition: AthenaMPToolBase.cxx:358
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore
StoreGateSvc_t m_evtStore
Pointer to StoreGate (event store by default)
Definition: AthCommonDataStore.h:390
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka
std::vector< SG::VarHandleKeyArray * > m_vhka
Definition: AthCommonDataStore.h:398
DeMoUpdate.statuses
list statuses
Definition: DeMoUpdate.py:568
AthenaMPToolBase::m_evtSelName
std::string m_evtSelName
Definition: AthenaMPToolBase.h:86
athena.exitcode
int exitcode
Definition: athena.py:161
read_hist_ntuple.t
t
Definition: read_hist_ntuple.py:5
AthenaMPToolBase::ESRANGE_SEEKFAILED
@ ESRANGE_SEEKFAILED
Definition: AthenaMPToolBase.h:59
EvtRangeProcessor::m_inpFile
std::string m_inpFile
Definition: EvtRangeProcessor.h:69
EvtRangeProcessor::m_evtSeek
SmartIF< IEvtSelectorSeek > m_evtSeek
Definition: EvtRangeProcessor.h:73
EvtRangeProcessor::m_rankId
int m_rankId
Definition: EvtRangeProcessor.h:66
EvtRangeProcessor::PROC_STATE_EXEC
@ PROC_STATE_EXEC
Definition: EvtRangeProcessor.h:61
python.utils.AtlRunQueryLookup.mask
string mask
Definition: AtlRunQueryLookup.py:460
Fd
IIoSvc::Fd Fd
Definition: IoSvc.cxx:22
sigaddset
#define sigaddset(x, y)
Definition: SealSignal.h:84
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
AthenaMPToolBase::FUNC_EXEC
@ FUNC_EXEC
Definition: AthenaMPToolBase.h:67
SG::VarHandleKeyArray::setOwner
virtual void setOwner(IDataHandleHolder *o)=0
COPY_FILE_HACK
#define COPY_FILE_HACK(_src, _dest)
Definition: copy_file_icc_hack.h:15
IDTPMcnv.htype
htype
Definition: IDTPMcnv.py:29
sigset_t
int sigset_t
Definition: SealSignal.h:80
EvtRangeProcessor::m_channel2EvtSel
StringProperty m_channel2EvtSel
Definition: EvtRangeProcessor.h:76
Cut::signal
@ signal
Definition: SUSYToolsAlg.cxx:67
AthenaMPToolBase::m_evtSelector
SmartIF< IEvtSelector > m_evtSelector
Definition: AthenaMPToolBase.h:94
python.utils.AtlRunQueryDQUtils.p
p
Definition: AtlRunQueryDQUtils.py:210
AthCommonDataStore
Definition: AthCommonDataStore.h:52
AthenaMPToolBase::m_appMgr
ServiceHandle< IAppMgrUI > m_appMgr
Definition: AthenaMPToolBase.h:91
EvtRangeProcessor::m_nProcessedEvents
std::map< pid_t, int > m_nProcessedEvents
Definition: EvtRangeProcessor.h:81
ATH_MSG_ERROR
#define ATH_MSG_ERROR(x)
Definition: AthMsgStreamMacros.h:33
EvtRangeProcessor::m_nEventsBeforeFork
int m_nEventsBeforeFork
Definition: EvtRangeProcessor.h:67
AthenaMPToolBase::m_isPileup
Gaudi::Property< bool > m_isPileup
Definition: AthenaMPToolBase.h:99
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
lumiFormat.i
int i
Definition: lumiFormat.py:85
python.DecayParser.buf
buf
print ("=> [%s]"cmd)
Definition: DecayParser.py:27
AthenaMPToolBase::Func_Flag
Func_Flag
Definition: AthenaMPToolBase.h:65
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
ATH_MSG_DEBUG
#define ATH_MSG_DEBUG(x)
Definition: AthMsgStreamMacros.h:29
EvtRangeProcessor::m_channel2Scatterer
StringProperty m_channel2Scatterer
Definition: EvtRangeProcessor.h:75
AthenaMPToolBase::reopenFd
int reopenFd(int fd, const std::string &name)
Definition: AthenaMPToolBase.cxx:444
AthenaMPToolBase::AthenaMPToolBase
AthenaMPToolBase()
ParticleGun_EoverP_Config.pid
pid
Definition: ParticleGun_EoverP_Config.py:62
AthenaMPToolBase::evtSelector
IEvtSelector * evtSelector()
Definition: AthenaMPToolBase.h:81
test_pyathena.parent
parent
Definition: test_pyathena.py:15
AthenaMPToolBase_d::pauseForDebug
void pauseForDebug(int)
Definition: AthenaMPToolBase.cxx:27
AthenaMPToolBase::ESRANGE_SUCCESS
@ ESRANGE_SUCCESS
Definition: AthenaMPToolBase.h:57
ATH_CHECK
#define ATH_CHECK
Definition: AthCheckMacros.h:40
EvtRangeProcessor::m_debug
bool m_debug
Definition: EvtRangeProcessor.h:85
TrigInDetValidation_Base.malloc
malloc
Definition: TrigInDetValidation_Base.py:132
AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore
StoreGateSvc_t m_detStore
Pointer to StoreGate (detector store by default)
Definition: AthCommonDataStore.h:393
AthenaMPToolBase::updateIoReg
int updateIoReg(const std::string &rundir)
Definition: AthenaMPToolBase.cxx:337
AthenaMPToolBase::initialize
virtual StatusCode initialize() override
Definition: AthenaMPToolBase.cxx:55
EvtRangeProcessor::m_sharedRankQueue
AthenaInterprocess::SharedQueue * m_sharedRankQueue
Definition: EvtRangeProcessor.h:78
AthenaInterprocess::SharedQueue::receive_basic
bool receive_basic(T &)
Definition: SharedQueue.h:124
SG::VarHandleKeyArray::renounce
virtual void renounce()=0
SG::HandleClassifier::type
std::conditional< std::is_base_of< SG::VarHandleKeyArray, T >::value, VarHandleKeyArrayType, type2 >::type type
Definition: HandleClassifier.h:54
ReadFromCoolCompare.fd
fd
Definition: ReadFromCoolCompare.py:196
EvtRangeProcessor::reportError
void reportError(yampl::ISocket *socket, AthenaMPToolBase::ESRange_Status status)
Definition: EvtRangeProcessor.cxx:796
EvtRangeProcessor::m_chronoStatSvc
ServiceHandle< IChronoStatSvc > m_chronoStatSvc
Definition: EvtRangeProcessor.h:71
merge_scale_histograms.doc
string doc
Definition: merge_scale_histograms.py:9
AthenaMPToolBase::ESRANGE_PROCFAILED
@ ESRANGE_PROCFAILED
Definition: AthenaMPToolBase.h:60
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:228
AthenaMPToolBase::m_ioMgr
ServiceHandle< IIoComponentMgr > m_ioMgr
Definition: AthenaMPToolBase.h:93
EvtRangeProcessor::setNewInputFile
StatusCode setNewInputFile(const std::string &newFile)
Definition: EvtRangeProcessor.cxx:762
AthenaMPToolBase::redirectLog
int redirectLog(const std::string &rundir, bool addTimeStamp=true)
Definition: AthenaMPToolBase.cxx:281
AthenaInterprocess::Process
Definition: Process.h:17
LArG4FSStartPointFilter.outdata
outdata
Definition: LArG4FSStartPointFilter.py:62
grepfile.filenames
list filenames
Definition: grepfile.py:34
Trk::open
@ open
Definition: BinningType.h:40
a
TList * a
Definition: liststreamerinfos.cxx:10
EvtRangeProcessor::PROC_STATE_INIT
@ PROC_STATE_INIT
Definition: EvtRangeProcessor.h:60
h
EvtRangeProcessor::m_incidentSvc
ServiceHandle< IIncidentSvc > m_incidentSvc
Definition: EvtRangeProcessor.h:72
ATH_MSG_WARNING
#define ATH_MSG_WARNING(x)
Definition: AthMsgStreamMacros.h:32
EvtRangeProcessor::m_sharedFailedPidQueue
AthenaInterprocess::SharedQueue * m_sharedFailedPidQueue
Definition: EvtRangeProcessor.h:79
AthenaInterprocess::FdsRegistryEntry
Definition: FdsRegistry.h:13
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
AthenaMP::AllWorkerOutputs_ptr
std::unique_ptr< AllWorkerOutputs > AllWorkerOutputs_ptr
Definition: IAthenaMPTool.h:28
CaloCellTimeCorrFiller.filename
filename
Definition: CaloCellTimeCorrFiller.py:24
SG::VarHandleBase::vhKey
SG::VarHandleKey & vhKey()
Return a non-const reference to the HandleKey.
Definition: StoreGate/src/VarHandleBase.cxx:623
CxxUtils::atoi
int atoi(std::string_view str)
Helper functions to unpack numbers decoded in string into integers and doubles The strings are requir...
Definition: Control/CxxUtils/Root/StringUtils.cxx:85
python.Bindings.keys
keys
Definition: Control/AthenaPython/python/Bindings.py:798
merge.status
status
Definition: merge.py:17
AthenaMPToolBase::m_subprocDirPrefix
std::string m_subprocDirPrefix
Definition: AthenaMPToolBase.h:85
AthenaMPToolBase::m_subprocTopDir
std::string m_subprocTopDir
Definition: AthenaMPToolBase.h:84
EvtRangeProcessor::PROC_STATE_FIN
@ PROC_STATE_FIN
Definition: EvtRangeProcessor.h:62
EvtRangeProcessor::PROC_STATE_STOP
@ PROC_STATE_STOP
Definition: EvtRangeProcessor.h:63
AthenaMPToolBase::ESRANGE_NOTFOUND
@ ESRANGE_NOTFOUND
Definition: AthenaMPToolBase.h:58
AthenaMPToolBase::handleSavedPfc
int handleSavedPfc(const std::filesystem::path &dest_path)
Definition: AthenaMPToolBase.cxx:421
AthenaMPToolBase::m_fileMgr
ServiceHandle< IFileMgr > m_fileMgr
Definition: AthenaMPToolBase.h:92
AthenaMP::AllWorkerOutputs
std::map< std::string, SingleWorkerOutputs > AllWorkerOutputs
Definition: IAthenaMPTool.h:25
AthCommonDataStore::declareGaudiProperty
Gaudi::Details::PropertyBase & declareGaudiProperty(Gaudi::Property< T > &hndl, const SG::VarHandleKeyType &)
specialization for handling Gaudi::Property<SG::VarHandleKey>
Definition: AthCommonDataStore.h:156
AthenaMPToolBase::FUNC_BOOTSTRAP
@ FUNC_BOOTSTRAP
Definition: AthenaMPToolBase.h:66
AthenaMPToolBase::reopenFds
int reopenFds()
Definition: AthenaMPToolBase.cxx:365
sigemptyset
#define sigemptyset(x)
Definition: SealSignal.h:82
AthenaMPToolBase::ESRANGE_FILENOTMADE
@ ESRANGE_FILENOTMADE
Definition: AthenaMPToolBase.h:61
AthenaMPToolBase::m_fdsRegistry
std::shared_ptr< AthenaInterprocess::FdsRegistry > m_fdsRegistry
Definition: AthenaMPToolBase.h:96
fitman.k
k
Definition: fitman.py:528
AthenaMPToolBase_d::sig_done
std::atomic< bool > sig_done
Definition: AthenaMPToolBase.cxx:26
AthenaMPToolBase::m_evtProcessor
ServiceHandle< IEventProcessor > m_evtProcessor
Definition: AthenaMPToolBase.h:90
Generated on Sun Dec 22 2024 21:33:03 for ATLAS Offline Software by   doxygen 1.8.18