AthenaMPToolBase Class Reference

#include <AthenaMPToolBase.h>

Inheritance diagram for AthenaMPToolBase:

Public Member Functions
	AthenaMPToolBase (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~AthenaMPToolBase () override
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual StatusCode wait_once	ATLAS_NOT_THREAD_SAFE (pid_t &pid) override
virtual void	reportSubprocessStatuses () override
virtual AthenaMP::AllWorkerOutputs_ptr	generateOutputReport () override
virtual void	useFdsRegistry (std::shared_ptr< AthenaInterprocess::FdsRegistry >) override
virtual void	setRandString (const std::string &randStr) override
virtual void	setMaxEvt (int maxEvt) override
virtual void	setMPRunStop (const AthenaInterprocess::IMPRunStop *runStop) 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
virtual std::unique_ptr< AthenaInterprocess::ScheduledWork >	exec_func ()=0
virtual std::unique_ptr< AthenaInterprocess::ScheduledWork >	fin_func ()=0
virtual std::unique_ptr< ScheduledWork >	operator () ATLAS_NOT_THREAD_SAFE(const ScheduledWork &)=0

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 ()

Protected Attributes
int	m_nprocs {-1}
	Number of workers spawned by the master process.
int	m_maxEvt {-1}
	Maximum number of events assigned to the job.
std::string	m_subprocTopDir
	Top run directory for subprocesses.
std::string	m_subprocDirPrefix
	For ex. "worker__".
std::string	m_evtSelName
	Name of the event selector.
AthenaInterprocess::ProcessGroup *	m_processGroup {nullptr}
const AthenaInterprocess::IMPRunStop *	m_mpRunStop {nullptr}
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 Member Functions
	AthenaMPToolBase ()
	AthenaMPToolBase (const AthenaMPToolBase &)
AthenaMPToolBase &	operator= (const AthenaMPToolBase &)
int	reopenFd (int fd, const std::string &name)

Detailed Description

Definition at line 23 of file AthenaMPToolBase.h.

Member Enumeration Documentation

ESRange_Status

enum AthenaMPToolBase::ESRange_Status

protected

Enumerator
ESRANGE_SUCCESS
ESRANGE_NOTFOUND
ESRANGE_SEEKFAILED
ESRANGE_PROCFAILED
ESRANGE_FILENOTMADE
ESRANGE_BADINPFILE

Definition at line 58 of file AthenaMPToolBase.h.

                      {
    ESRANGE_SUCCESS
    , ESRANGE_NOTFOUND
    , ESRANGE_SEEKFAILED
    , ESRANGE_PROCFAILED
    , ESRANGE_FILENOTMADE
    , ESRANGE_BADINPFILE
  };

Func_Flag

enum AthenaMPToolBase::Func_Flag

protected

Enumerator
FUNC_BOOTSTRAP
FUNC_EXEC
FUNC_FIN

Definition at line 67 of file AthenaMPToolBase.h.

                 {
    FUNC_BOOTSTRAP
    , FUNC_EXEC
    , FUNC_FIN
  };

Constructor & Destructor Documentation

AthenaMPToolBase() [1/3]

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

Definition at line 33 of file AthenaMPToolBase.cxx.

  : base_class(type,name,parent)
  , m_evtProcessor("AthenaEventLoopMgr",name)
  , m_appMgr("ApplicationMgr",name)
  , m_fileMgr("FileMgr",name)
  , m_ioMgr("IoComponentMgr",name)
{
}

~AthenaMPToolBase()

AthenaMPToolBase::~AthenaMPToolBase ( )

overridevirtual

Definition at line 44 of file AthenaMPToolBase.cxx.

{
}

AthenaMPToolBase() [2/3]

AthenaMPToolBase::AthenaMPToolBase ( )

private

AthenaMPToolBase() [3/3]

AthenaMPToolBase::AthenaMPToolBase ( const AthenaMPToolBase & )

private

Member Function Documentation

ATLAS_NOT_THREAD_SAFE() [1/2]

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

protected

ATLAS_NOT_THREAD_SAFE() [2/2]

virtual StatusCode wait_once AthenaMPToolBase::ATLAS_NOT_THREAD_SAFE ( pid_t & pid )

overridevirtual

Reimplemented in EvtRangeProcessor, SharedEvtQueueConsumer, and SharedHiveEvtQueueConsumer.

bootstrap_func()

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

pure virtual

Implemented in EvtRangeProcessor, EvtRangeScatterer, SharedEvtQueueConsumer, SharedHiveEvtQueueConsumer, and SharedWriterTool.

evtSelector()

IEvtSelector * AthenaMPToolBase::evtSelector ( )

inlineprotected

Definition at line 83 of file AthenaMPToolBase.h.

{ return m_evtSelector; }

exec_func()

virtual std::unique_ptr< AthenaInterprocess::ScheduledWork > AthenaMPToolBase::exec_func ( )

pure virtual

Implemented in EvtRangeProcessor, EvtRangeScatterer, SharedEvtQueueConsumer, SharedHiveEvtQueueConsumer, and SharedWriterTool.

fin_func()

virtual std::unique_ptr< AthenaInterprocess::ScheduledWork > AthenaMPToolBase::fin_func ( )

pure virtual

Implemented in EvtRangeProcessor, EvtRangeScatterer, SharedEvtQueueConsumer, SharedHiveEvtQueueConsumer, and SharedWriterTool.

finalize()

StatusCode AthenaMPToolBase::finalize ( )

overridevirtual

Reimplemented in EvtRangeScatterer, SharedEvtQueueConsumer, SharedHiveEvtQueueConsumer, and SharedWriterTool.

Definition at line 87 of file AthenaMPToolBase.cxx.

{
  return StatusCode::SUCCESS;
}

fmterror()

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

protected

Definition at line 333 of file AthenaMPToolBase.cxx.

{
  char buf[256];
  strerror_r(errnum, buf, sizeof(buf));
  return std::string(buf);
}

generateOutputReport()

AthenaMP::AllWorkerOutputs_ptr AthenaMPToolBase::generateOutputReport ( )

overridevirtual

Reimplemented in EvtRangeProcessor, EvtRangeScatterer, and SharedWriterTool.

Definition at line 119 of file AthenaMPToolBase.cxx.

{
  AthenaMP::AllWorkerOutputs_ptr jobOutputs(new AthenaMP::AllWorkerOutputs());
 
  if(m_fileMgrLog.empty()) {
    ATH_MSG_WARNING(name() << " cannot make output report because FileMgr has not been configured to write log file!");
  }
  else {
    // Collect output files made by the workers
    std::string line;
    for(int i=0;i<m_nprocs;++i) {
      // Get the name of FileMgr log
      std::ostringstream workindex;
      workindex<<i;
      std::filesystem::path logFilePath(m_subprocTopDir);
      logFilePath /= std::filesystem::path(m_subprocDirPrefix+workindex.str());
      std::filesystem::path logFile(logFilePath);
      logFile /= std::filesystem::path(m_fileMgrLog);
      if(!(std::filesystem::exists(logFile)&&std::filesystem::is_regular_file(logFile))) {
        ATH_MSG_WARNING(logFile.string() << " either does not exist or is not a regular file. Skipping");
        continue;
      }
 
      ATH_MSG_DEBUG("FileMgr log file (" << i << ") " << logFile);
 
      std::ifstream inpStream(logFile.string().c_str());
      std::set<std::string> reportedFiles; // Don't report the same file twice
      while(!inpStream.eof()) {
    std::getline(inpStream,line);
        if(line.find("WRITE")!=std::string::npos) {
          // Parse the entry
          size_t startpos(0);
      std::vector<std::string> entries;
          while(startpos<line.size()) {
            while(line[startpos]==' ')
              startpos++;
 
            size_t endpos = line.find(' ',startpos);
            if(endpos==std::string::npos) endpos = line.size();
            entries.push_back(line.substr(startpos,endpos-startpos));
            startpos=endpos+1;
          }
 
          // enties[0] is filename
      std::filesystem::path filenamePath(entries[0]);
      std::filesystem::path basename = filenamePath.filename();
          if(reportedFiles.find(basename.string())==reportedFiles.end())
            reportedFiles.insert(basename.string());
          else
            continue;
      std::filesystem::path absolutename = basename.is_absolute() ? basename : std::filesystem::absolute(std::filesystem::path(logFilePath)/=basename);
      AthenaMP::AllWorkerOutputsIterator it1 = jobOutputs->find(basename.string());
          if(it1==jobOutputs->end()) {
            (*jobOutputs)[basename.string()] = AthenaMP::SingleWorkerOutputs();
            (*jobOutputs)[basename.string()].reserve(m_nprocs);
          }
 
      AthenaMP::WorkerOutput newOutput;
          newOutput.filename = absolutename.string();
          newOutput.technology = entries[1];
          newOutput.description = entries[2];
          newOutput.access_mode = entries[3];
          newOutput.shared = (line.find("SHARED")!=std::string::npos);
 
          (*jobOutputs)[basename.string()].emplace_back(std::move(newOutput));
        }
      }
    }
  }
  return jobOutputs;
}

handleSavedPfc()

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

protected

Definition at line 396 of file AthenaMPToolBase.cxx.

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

initialize()

StatusCode AthenaMPToolBase::initialize ( )

overridevirtual

Reimplemented in EvtRangeProcessor, EvtRangeScatterer, SharedEvtQueueConsumer, SharedHiveEvtQueueConsumer, and SharedWriterTool.

Definition at line 48 of file AthenaMPToolBase.cxx.

{
  ATH_MSG_DEBUG("In initialize");
 
  if(m_isPileup) {
    m_evtProcessor = ServiceHandle<IEventProcessor>("PileUpEventLoopMgr",name());
    ATH_MSG_INFO("The job running in pileup mode");
  }
  else {
    ATH_MSG_INFO("The job running in non-pileup mode");
  }
 
  ATH_CHECK(m_evtProcessor.retrieve());
  ATH_CHECK(m_appMgr.retrieve());
 
  SmartIF<IProperty> prpMgr(serviceLocator());
  if(prpMgr.isValid()) {
    // Get event selector name. Retrieve EventSelector and EventSeek
    m_evtSelName = prpMgr->getProperty("EvtSel").toString();
    // If the job runs with no event selector, then the name will be empty
    if(!m_evtSelName.empty()) {
      m_evtSelector = serviceLocator()->service(m_evtSelName);
      ATH_CHECK(m_evtSelector.isValid());
    }
  }
  else {
    ATH_MSG_ERROR("IProperty interface not found in ApplicationMgr");
    return StatusCode::FAILURE;
  }
 
  ATH_CHECK(m_fileMgr.retrieve());
 
  SmartIF<IProperty> prpMgr1(m_fileMgr.get());
  ATH_CHECK(prpMgr1.isValid());
  m_fileMgrLog = prpMgr1->getProperty("LogFile").toString();
 
  return StatusCode::SUCCESS;
}

killChildren()

void AthenaMPToolBase::killChildren ( )

overridevirtual

Definition at line 201 of file AthenaMPToolBase.cxx.

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

operator()

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

pure virtualinherited

operator=()

AthenaMPToolBase & AthenaMPToolBase::operator= ( const AthenaMPToolBase & )

private

redirectLog()

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

protected

Definition at line 269 of file AthenaMPToolBase.cxx.

{
  // Redirect both stdout and stderr to the same file AthenaMP.log
  int dup2result1(0), dup2result2(0);
 
  int newout = open(std::string(rundir+"/AthenaMP.log").c_str(),O_CREAT | O_RDWR, S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH);
  if(newout==-1) {
    ATH_MSG_ERROR("Unable to open log file in the run directory. " << fmterror(errno));
    return -1;
  }
  dup2result1 = dup2(newout, STDOUT_FILENO);
  dup2result2 = dup2(newout, STDERR_FILENO);
  TEMP_FAILURE_RETRY(close(newout));
  if(dup2result1==-1) {
    ATH_MSG_ERROR("Unable to redirect standard output. " << fmterror(errno));
    return -1;
  }
  if(dup2result2==-1) {
    ATH_MSG_ERROR("Unable to redirect standard error. " << fmterror(errno));
    return -1;
  }
 
  if(addTimeStamp) {
    SmartIF<IProperty> propertyServer(msgSvc());
    if(propertyServer==0) {
      ATH_MSG_ERROR("Unable to cast message svc to IProperty");
      return -1;
    }
 
    std::string propertyName("Format");
    std::string oldFormat("");
    StringProperty formatProp(propertyName,oldFormat);
    StatusCode sc = propertyServer->getProperty(&formatProp);
    if(sc.isFailure()) {
      ATH_MSG_WARNING("Message Service does not have Format property");
    }
    else {
      oldFormat = formatProp.value();
      if(oldFormat.find("%t")==std::string::npos) {
        // Add time stamps
        std::string newFormat("%t " + oldFormat);
        StringProperty newFormatProp(std::move(propertyName),newFormat);
        ATH_CHECK(propertyServer->setProperty(newFormatProp), -1);
      }
      else {
        ATH_MSG_DEBUG("MsgSvc format already contains timestamps. Nothing to be done");
      }
    }
  }
 
  return 0;
}

reopenFd()

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

private

Definition at line 419 of file AthenaMPToolBase.cxx.

{
  ATH_MSG_DEBUG("Attempting to reopen descriptor for " << name);
  int old_openflags = fcntl(fd,F_GETFL,0);
  switch(old_openflags & O_ACCMODE) {
  case O_RDONLY: {
    ATH_MSG_DEBUG("The File Access Mode is RDONLY");
    break;
  }
  case O_WRONLY: {
    ATH_MSG_DEBUG("The File Access Mode is WRONLY");
    break;
  }
  case O_RDWR: {
    ATH_MSG_DEBUG("The File Access Mode is RDWR");
    break;
  }
  }
   
  int old_descflags = fcntl(fd,F_GETFD,0);
  off_t oldpos = lseek(fd,0,SEEK_CUR);
  if(oldpos==-1) {
    if(errno==ESPIPE) {
      ATH_MSG_WARNING("Dealing with PIPE. Skipping ... (FIXME!)");
    }
    else {
      ATH_MSG_ERROR("When re-opening file descriptors lseek failed on " << name << ". " << fmterror(errno));
      return -1;
    }
  }
  else {
    Io::Fd newfd = open(name.c_str(),old_openflags);
    if(newfd==-1) {
      ATH_MSG_ERROR("When re-opening file descriptors unable to open " << name << " for reading. " << fmterror(errno));
      return -1;
    }
    if(lseek(newfd,oldpos,SEEK_SET)==-1){
      ATH_MSG_ERROR("When re-opening file descriptors lseek failed on the newly opened " << name << ". " << fmterror(errno));
      TEMP_FAILURE_RETRY(close(newfd));
      return -1;
    }
    TEMP_FAILURE_RETRY(close(fd));
    if(dup2(newfd,fd)==-1) {
      ATH_MSG_ERROR("When re-opening file descriptors unable to duplicate descriptor for " << name << ". " << fmterror(errno));
      TEMP_FAILURE_RETRY(close(newfd));
      return -1;
    }
    if(fcntl(fd,F_SETFD,old_descflags)==-1) {
      ATH_MSG_ERROR("When re-opening file descriptors unable to set descriptor flags for " << name << ". " << fmterror(errno));
      TEMP_FAILURE_RETRY(close(newfd));
      return -1;
    }
    TEMP_FAILURE_RETRY(close(newfd));
  }
  return 0;
}

reopenFds()

int AthenaMPToolBase::reopenFds ( )

protected

Definition at line 340 of file AthenaMPToolBase.cxx.

{
  // Reopen file descriptors.
  // First go over all open files, which have been registered with the FileMgr
  // Then also check the FdsRegistry, in case it contains some files not registered with the FileMgr
  std::set<int> fdLog;
  
  // Query the FileMgr contents
  std::vector<const Io::FileAttr*> filemgrFiles;
  std::vector<const Io::FileAttr*>::const_iterator itFile;
  unsigned filenum = m_fileMgr->getFiles(filemgrFiles); // Get attributes for open files only. We don't care about closed ones at this point
  if(filenum!=filemgrFiles.size())
    ATH_MSG_WARNING("getFiles returned " << filenum << " while vector size is " << filemgrFiles.size());
  
  for(itFile=filemgrFiles.begin();itFile!=filemgrFiles.end();++itFile) {
    ATH_MSG_DEBUG("* " << **itFile);
    const std::string& filename = (**itFile).name();
    Io::Fd fd = (**itFile).fd();
 
    if(fd==-1) {
      // It is legal to have fd=-1 for remote inputs
      // On the other hand, these inputs should not remain open after fork. The issue being tracked at ATEAM-434.
      // So, this hopefully is a temporary patch
      ATH_MSG_WARNING("FD=-1 detected on an open file retrieved from FileMgr. Skip FD reopening. File name: " << filename);
      continue;
    }
    
    if(reopenFd(fd,filename))
      return -1;
    
    fdLog.insert(fd);
  }
  
  // Check the FdsRegistry
  for(const AthenaInterprocess::FdsRegistryEntry& regEntry : *m_fdsRegistry) {
    if(fdLog.find(regEntry.fd)!=fdLog.end()) {
      ATH_MSG_DEBUG("The file from FdsRegistry " << regEntry.name << " was registered with FileMgr. Skip reopening");
    }
    else {
      ATH_MSG_WARNING("The file " << regEntry.name << " has not been registered with the FileMgr!");
      
      if(regEntry.fd==-1) {
      // Same protection as the one above
    ATH_MSG_WARNING("FD=-1 detected on an open file retrieved from FD Registry. Skip FD reopening. File name: " << regEntry.name);
    continue;
      }
 
      if(reopenFd(regEntry.fd,regEntry.name))
        return -1;
      
      fdLog.insert(regEntry.fd);
    }
  }
  return 0;
}

reportSubprocessStatuses()

void AthenaMPToolBase::reportSubprocessStatuses ( )

overridevirtual

Reimplemented in EvtRangeProcessor, SharedEvtQueueConsumer, and SharedHiveEvtQueueConsumer.

Definition at line 111 of file AthenaMPToolBase.cxx.

{
  ATH_MSG_INFO("Statuses of sub-processes");
  const std::vector<AthenaInterprocess::ProcessStatus>& statuses = m_processGroup->getStatuses();
  for(size_t i=0; i<statuses.size(); ++i)
    ATH_MSG_INFO("*** Process PID=" << statuses[i].pid << ". Status " << ((statuses[i].exitcode)?"FAILURE":"SUCCESS"));
}

setMaxEvt()

virtual void AthenaMPToolBase::setMaxEvt ( int maxEvt )

inlineoverridevirtual

Definition at line 44 of file AthenaMPToolBase.h.

{m_maxEvt=maxEvt;}

setMPRunStop()

virtual void AthenaMPToolBase::setMPRunStop ( const AthenaInterprocess::IMPRunStop * runStop )

inlineoverridevirtual

Definition at line 45 of file AthenaMPToolBase.h.

{m_mpRunStop=runStop;}

setRandString()

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

overridevirtual

Definition at line 196 of file AthenaMPToolBase.cxx.

{
  m_randStr = randStr;
}

updateIoReg()

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

protected

Definition at line 322 of file AthenaMPToolBase.cxx.

{
  ATH_CHECK(m_ioMgr.retrieve(), -1);
 
  // update the IoRegistry for the new workdir - make sure we use absolute path
  std::filesystem::path abs_rundir = std::filesystem::absolute(rundir);
  ATH_CHECK(m_ioMgr->io_update_all(abs_rundir.string()), -1);
 
  return 0;
}

useFdsRegistry()

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

overridevirtual

Definition at line 191 of file AthenaMPToolBase.cxx.

{
  m_fdsRegistry = std::move(registry);
}

waitForSignal()

void AthenaMPToolBase::waitForSignal ( )

protected

Definition at line 403 of file AthenaMPToolBase.cxx.

{
  ATH_MSG_INFO("Bootstrap worker PID " << getpid() << " - waiting for SIGUSR1");
  sigset_t mask, oldmask;
  
  signal(SIGUSR1, AthenaMPToolBase_d::pauseForDebug);
  
  sigemptyset (&mask);
  sigaddset (&mask, SIGUSR1);
  
  sigprocmask (SIG_BLOCK, &mask, &oldmask);
  while (!AthenaMPToolBase_d::sig_done)
    sigsuspend (&oldmask);
  sigprocmask (SIG_UNBLOCK, &mask, NULL);
}

Member Data Documentation

m_appMgr

ServiceHandle<IAppMgrUI> AthenaMPToolBase::m_appMgr

protected

Definition at line 95 of file AthenaMPToolBase.h.

m_evtProcessor

ServiceHandle<IEventProcessor> AthenaMPToolBase::m_evtProcessor

protected

Definition at line 94 of file AthenaMPToolBase.h.

m_evtSelector

SmartIF<IEvtSelector> AthenaMPToolBase::m_evtSelector

protected

Definition at line 98 of file AthenaMPToolBase.h.

m_evtSelName

std::string AthenaMPToolBase::m_evtSelName

protected

Name of the event selector.

Definition at line 89 of file AthenaMPToolBase.h.

m_fdsRegistry

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

protected

Definition at line 100 of file AthenaMPToolBase.h.

m_fileMgr

ServiceHandle<IFileMgr> AthenaMPToolBase::m_fileMgr

protected

Definition at line 96 of file AthenaMPToolBase.h.

m_fileMgrLog

std::string AthenaMPToolBase::m_fileMgrLog

protected

Definition at line 99 of file AthenaMPToolBase.h.

m_ioMgr

ServiceHandle<IIoComponentMgr> AthenaMPToolBase::m_ioMgr

protected

Definition at line 97 of file AthenaMPToolBase.h.

m_isPileup

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

protected

Definition at line 103 of file AthenaMPToolBase.h.

{this, "IsPileup", false, "Flag for configuring PileUpEventLoopMgr"};

m_maxEvt

int AthenaMPToolBase::m_maxEvt {-1}

protected

Maximum number of events assigned to the job.

Definition at line 86 of file AthenaMPToolBase.h.

{-1};       

m_mpRunStop

const AthenaInterprocess::IMPRunStop* AthenaMPToolBase::m_mpRunStop {nullptr}

protected

Definition at line 92 of file AthenaMPToolBase.h.

{nullptr};

m_nprocs

int AthenaMPToolBase::m_nprocs {-1}

protected

Number of workers spawned by the master process.

Definition at line 85 of file AthenaMPToolBase.h.

{-1};       

m_processGroup

AthenaInterprocess::ProcessGroup* AthenaMPToolBase::m_processGroup {nullptr}

protected

Definition at line 91 of file AthenaMPToolBase.h.

{nullptr};

m_randStr

std::string AthenaMPToolBase::m_randStr

protected

Definition at line 101 of file AthenaMPToolBase.h.

m_subprocDirPrefix

std::string AthenaMPToolBase::m_subprocDirPrefix

protected

For ex. "worker__".

Definition at line 88 of file AthenaMPToolBase.h.

m_subprocTopDir

std::string AthenaMPToolBase::m_subprocTopDir

protected

Top run directory for subprocesses.

Definition at line 87 of file AthenaMPToolBase.h.

---

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

• AthenaMPToolBase.h
• AthenaMPToolBase.cxx