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
 
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
 
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 379 of file EvtRangeProcessor.cxx.

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

◆ 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 495 of file EvtRangeProcessor.cxx.

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

◆ 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 706 of file EvtRangeProcessor.cxx.

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

◆ finalize()

StatusCode EvtRangeProcessor::finalize ( )
overridevirtual

Reimplemented from AthenaMPToolBase.

Definition at line 76 of file EvtRangeProcessor.cxx.

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

◆ fmterror()

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

Definition at line 362 of file AthenaMPToolBase.cxx.

363 {
364  char buf[256];
365  strerror_r(errnum, buf, sizeof(buf));
366  return std::string(buf);
367 }

◆ generateOutputReport()

AthenaMP::AllWorkerOutputs_ptr EvtRangeProcessor::generateOutputReport ( )
overridevirtual

Reimplemented from AthenaMPToolBase.

Definition at line 373 of file EvtRangeProcessor.cxx.

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

◆ handleSavedPfc()

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

Definition at line 425 of file AthenaMPToolBase.cxx.

426 {
427  if(std::filesystem::is_regular_file("PoolFileCatalog.xml.AthenaMP-saved"))
428  COPY_FILE_HACK("PoolFileCatalog.xml.AthenaMP-saved",dest_path.string()+"/PoolFileCatalog.xml");
429  return 0;
430 }

◆ 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  ATH_CHECK(serviceLocator()->service(m_evtSelName,m_evtSeek));
70  ATH_CHECK(m_chronoStatSvc.retrieve());
71  ATH_CHECK(m_incidentSvc.retrieve());
72 
73  return StatusCode::SUCCESS;
74 }

◆ 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 210 of file AthenaMPToolBase.cxx.

211 {
212  for(const AthenaInterprocess::Process& child : m_processGroup->getChildren()) {
213  kill(child.getProcessID(),SIGKILL);
214  }
215 }

◆ 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 278 of file AthenaMPToolBase.cxx.

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

◆ 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 448 of file AthenaMPToolBase.cxx.

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

◆ reopenFds()

int AthenaMPToolBase::reopenFds ( )
protectedinherited

Definition at line 369 of file AthenaMPToolBase.cxx.

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

◆ reportError()

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

Definition at line 795 of file EvtRangeProcessor.cxx.

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

◆ reportSubprocessStatuses()

void EvtRangeProcessor::reportSubprocessStatuses ( )
overridevirtual

Reimplemented from AthenaMPToolBase.

Definition at line 343 of file EvtRangeProcessor.cxx.

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

◆ setNewInputFile()

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

Definition at line 761 of file EvtRangeProcessor.cxx.

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

◆ setRandString()

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

Implements IAthenaMPTool.

Definition at line 205 of file AthenaMPToolBase.cxx.

206 {
207  m_randStr = randStr;
208 }

◆ subProcessLogs()

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

Implements IAthenaMPTool.

Definition at line 361 of file EvtRangeProcessor.cxx.

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

◆ 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 341 of file AthenaMPToolBase.cxx.

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

◆ 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 200 of file AthenaMPToolBase.cxx.

201 {
202  m_fdsRegistry = registry;
203 }

◆ waitForSignal()

void AthenaMPToolBase::waitForSignal ( )
protectedinherited

Definition at line 432 of file AthenaMPToolBase.cxx.

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

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

IEvtSelectorSeek* EvtRangeProcessor::m_evtSeek
private

Definition at line 73 of file EvtRangeProcessor.h.

◆ m_evtSelector

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:432
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
athena.path
path
python interpreter configuration --------------------------------------—
Definition: athena.py:126
EvtRangeProcessor::m_activeWorkers
int m_activeWorkers
Definition: EvtRangeProcessor.h:68
AthenaMPToolBase::ESRANGE_BADINPFILE
@ ESRANGE_BADINPFILE
Definition: AthenaMPToolBase.h:62
AthenaMPToolBase::m_evtSelector
IEvtSelector * m_evtSelector
Definition: AthenaMPToolBase.h:94
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:32
skel.it
it
Definition: skel.GENtoEVGEN.py:423
AthenaMPToolBase::fmterror
std::string fmterror(int errnum)
Definition: AthenaMPToolBase.cxx:362
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:159
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_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
EvtRangeProcessor::m_evtSeek
IEvtSelectorSeek * m_evtSeek
Definition: EvtRangeProcessor.h:73
sigset_t
int sigset_t
Definition: SealSignal.h:80
EvtRangeProcessor::m_channel2EvtSel
StringProperty m_channel2EvtSel
Definition: EvtRangeProcessor.h:76
IEvtSelectorSeek::seek
virtual StatusCode seek(IEvtSelector::Context &c, int evtnum) const =0
Seek to a given event number.
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
lumiFormat.i
int i
Definition: lumiFormat.py:92
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:448
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:129
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:341
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:795
EvtRangeProcessor::m_chronoStatSvc
ServiceHandle< IChronoStatSvc > m_chronoStatSvc
Definition: EvtRangeProcessor.h:71
Cut::signal
@ signal
Definition: SUSYToolsAlg.cxx:64
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:192
AthenaMPToolBase::m_ioMgr
ServiceHandle< IIoComponentMgr > m_ioMgr
Definition: AthenaMPToolBase.h:93
EvtRangeProcessor::setNewInputFile
StatusCode setNewInputFile(const std::string &newFile)
Definition: EvtRangeProcessor.cxx:761
AthenaMPToolBase::redirectLog
int redirectLog(const std::string &rundir, bool addTimeStamp=true)
Definition: AthenaMPToolBase.cxx:278
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
HFORType::kill
@ kill
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:616
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
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:790
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:425
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:369
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 Jun 30 2024 21:45:03 for ATLAS Offline Software by   doxygen 1.8.18