def hack_copy(srcDir, destDir):
""" explicitly copy files not captured by IoRegistry"""
#couple of sanity checks
if srcDir == '':
srcDir = os.curdir
if srcDir == destDir:
from AthenaCommon.Logging import log as msg
msg.warning("hack_copy called with srcDir = destDir = "+srcDir)
return
#A hack for RDO reconstruction after nextEvent(n)
filepattern_list = [ 'DigitParams.db', 'SimParams.db',
'*.pmon.stream' ]
import fnmatch
import shutil
import os
for pattern in filepattern_list:
for f in os.listdir(srcDir):
if fnmatch.fnmatch(f, pattern):
import os.path
src_path = os.path.join(srcDir,f)
dest_path = os.path.join(destDir,f)
if not os.path.isfile(dest_path):
shutil.copyfile(src_path, dest_path)
def root6_importhook(name,
globals={},
locals={},
fromlist=[],
level=-1):
if name == 'PyCintex':
import sys, traceback
source, line, f, t = traceback.extract_stack(
sys._getframe(1))[-1]
log.warning(
'PyCintex imported (replace with import cppyy) from: %s:%d'
% (source, line))
m = oldimporthook(name, globals, locals, fromlist, level)
if m and (m.__name__ == 'ROOT' or name[0:4] == 'ROOT'):
log.debug('Python import module=%s fromlist=%s' %
(name, str(fromlist)))
if fromlist:
#MN: in this case 'm' is the final nested module already, don't walk the full 'name'
vars = [
'.'.join(['', fl, autoload_var_name])
for fl in fromlist
]
else:
vars = ['.'.join([name, autoload_var_name])]
for v in vars:
try:
mm = m
#MN: walk the module chain and try to touch 'autoload_var_name' to trigger ROOT autoloading of namespaces
for comp in v.split('.')[1:]:
mm = getattr(mm, comp)
except:
pass
return m
def enable_seeking(silent=False):
""" try to install seek-stuff on the EventSelector side.
if `silent` is True, only an attempt at installing the seeking is performed.
otherwise an exception is raised if the seeking could not be installed.
"""
import sys
from AthenaCommon.Logging import log as msg
if not sys.modules.has_key('AthenaPoolCnvSvc.ReadAthenaPool'):
if silent:
_msg = msg.debug
else:
_msg = msg.info
# user did not import that module so we give up
_msg("Cannot enable 'seeking' b/c module "
"[AthenaPoolCnvSvc.ReadAthenaPool] hasn't been imported...")
_msg( "Modify your jobOptions to import that module "+ \
"(or just ignore this message)" )
if not silent:
raise RuntimeError("configuration-logic error")
return
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaCommon.Configurable import Configurable
collectionType = svcMgr.EventSelector.properties()["CollectionType"]
if collectionType in (
"ImplicitROOT",
Configurable.propertyNoValue,
):
svcMgr.EventSelector.CollectionType = "SeekableROOT"
msg.info("=> Seeking enabled.")
elif collectionType in ("SeekableROOT", ):
msg.verbose("=> Seeking already enabled.")
else:
msg.warning(
"Input seeking is not compatible with collection type of %s",
svcMgr.EventSelector.properties()["CollectionType"])
msg.warning("=> Seeking disabled.")
if not silent:
raise RuntimeError("could not install seeking")
from AthenaCommon.AppMgr import theApp
if theApp.state() != theApp.State.OFFLINE:
# do not bring up the whole C++ kaboodle too early in the game
svcMgr.EventSelector.setup()
return
def _do_action(self):
import multiprocessing
if (self.get_Value() == -1):
self.set_Value(multiprocessing.cpu_count())
elif (self.get_Value() < -1):
from AthenaCommon.Logging import log
log.fatal("nprocs cannot be < -1")
import sys
from AthenaCommon import ExitCodes
sys.exit(ExitCodes.CONFIGURATION_ERROR)
elif (self.get_Value() > multiprocessing.cpu_count()):
from AthenaCommon.Logging import log
log.warning("nprocs is larger than core count [%s]!",
multiprocessing.cpu_count())
return
def enable_seeking(silent=False):
""" try to install seek-stuff on the EventSelector side.
if `silent` is True, only an attempt at installing the seeking is performed.
otherwise an exception is raised if the seeking could not be installed.
"""
import sys
from AthenaCommon.Logging import log as msg
if not sys.modules.has_key( 'AthenaPoolCnvSvc.ReadAthenaPool' ):
if silent:
_msg = msg.debug
else:
_msg = msg.info
# user did not import that module so we give up
_msg( "Cannot enable 'seeking' b/c module "
"[AthenaPoolCnvSvc.ReadAthenaPool] hasn't been imported..." )
_msg( "Modify your jobOptions to import that module "+ \
"(or just ignore this message)" )
if not silent:
raise RuntimeError("configuration-logic error")
return
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaCommon.Configurable import Configurable
collectionType = svcMgr.EventSelector.properties()["CollectionType"]
if collectionType in ( "ImplicitROOT", Configurable.propertyNoValue, ):
svcMgr.EventSelector.CollectionType = "SeekableROOT"
msg.info ( "=> Seeking enabled." )
elif collectionType in ( "SeekableROOT", ):
msg.verbose( "=> Seeking already enabled." )
else:
msg.warning( "Input seeking is not compatible with collection type of %s",
svcMgr.EventSelector.properties()["CollectionType"] )
msg.warning( "=> Seeking disabled." )
if not silent:
raise RuntimeError("could not install seeking")
from AthenaCommon.AppMgr import theApp
if theApp.state() != theApp.State.OFFLINE:
# do not bring up the whole C++ kaboodle too early in the game
svcMgr.EventSelector.setup()
return
def setupEvtSelForSeekOps():
""" try to install seek-stuff on the EventSelector side """
#import sys
#from AthenaCommon.Logging import log as msg
msg.debug("setupEvtSelForSeekOps:")
if sys.modules.has_key('AthenaRootComps.ReadAthenaRoot'):
# athenarootcomps has seeking enabled by default
msg.info('=> Seeking enabled.')
return
if not sys.modules.has_key('AthenaPoolCnvSvc.ReadAthenaPool'):
## user did not import that module so we give up
msg.info( "Cannot enable 'seeking' b/c module " + \
"[AthenaPoolCnvSvc.ReadAthenaPool] hasn't been imported..." )
msg.info( "Modify your jobOptions to import that module "+ \
"(or just ignore this message)" )
return
from AthenaCommon.AppMgr import theApp, AthAppMgr
if theApp.state() != AthAppMgr.State.OFFLINE:
msg.info( "C++ ApplicationMgr already instantiated, probably seeking "+\
"will be ill-configured..." )
msg.info("EventSelector writers should implement updateHandlers")
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaCommon.Configurable import Configurable
collectionType = svcMgr.EventSelector.properties()["CollectionType"]
if collectionType in (
"ImplicitROOT",
Configurable.propertyNoValue,
):
svcMgr.EventSelector.CollectionType = "SeekableROOT"
msg.info("=> Seeking enabled.")
elif collectionType in ("SeekableROOT", ):
msg.verbose("=> Seeking already enabled.")
else:
msg.warning(
"Input seeking is not compatible with collection type of %s",
svcMgr.EventSelector.properties()["CollectionType"])
msg.warning("=> Seeking disabled.")
return
def reopen_fds(wkdir=""):
"""redirect workers fds by setting proper flags
<INPUT> -> duplicate fd in RDONLY mode
<OUTPUT> -> redirect fd to local output-copy w/ duplicate flags.
"""
_info("reopen_fds: in dir [%s]" % wkdir)
import os, fcntl
#from IoRegistry import IoRegistry as ioreg
_join = os.path.join
_fds = IoRegistry.fds_dict
_fds.create_symlinks(wkdir)
for k, v in _fds.iteritems():
fd = k
(real_name, iomode, flags) = v
if not os.path.isfile(real_name):
_debug("reopen_fds: %s is not file" % real_name)
continue
if (iomode == '<OUTPUT>'):
#expect the copy of <OUTPUT> to be in curdir
_debug("reopen_fds: <OUTPUT> %s " % real_name)
pos = os.lseek(fd, 0, os.SEEK_CUR)
#PC HACK remove!
try:
new_fd = os.open(_join(wkdir, os.path.basename(real_name)),
flags)
os.lseek(new_fd, pos, os.SEEK_SET)
except Exception, err:
msg.warning("Exception caught handling OUTPUT file %s: %s" %
(real_name, err))
msg.warning(" ...ignoring file FIXME!")
continue
else:
_debug("reopen_fds:<INPUT> %s" % real_name)
new_fd = os.open(real_name, os.O_RDONLY)
os.close(fd)
os.dup2(new_fd, fd)
fcntl.fcntl(fd, fcntl.F_SETFL, flags)
os.close(new_fd)
def ActsTrackingGeometrySvcCfg(configFlags, name="ActsTrackingGeometrySvc"):
result = ComponentAccumulator()
Acts_ActsTrackingGeometrySvc = CompFactory.ActsTrackingGeometrySvc
subDetectors = []
if configFlags.Detector.GeometryPixel:
subDetectors += ["Pixel"]
if configFlags.Detector.GeometrySCT:
subDetectors += ["SCT"]
if configFlags.Detector.GeometryTRT:
subDetectors += ["TRT"]
if configFlags.Detector.GeometryCalo:
subDetectors += ["Calo"]
# need to configure calo geometry, otherwise we get a crash
from LArGeoAlgsNV.LArGMConfig import LArGMCfg
result.merge(LArGMCfg(configFlags))
from TileGeoModel.TileGMConfig import TileGMCfg
result.merge(TileGMCfg(configFlags))
idSub = [sd in subDetectors for sd in ("Pixel", "SCT", "TRT")]
if any(idSub):
# ANY of the ID subdetectors are on => we require GM sources
# In principle we could require only what is enabled, but the group
# does extra config that I don't want to duplicate here
from AtlasGeoModel.InDetGMConfig import InDetGeometryCfg
result.merge(InDetGeometryCfg(configFlags))
if not all(idSub):
from AthenaCommon.Logging import log
log.warning(
"ConfigFlags indicate %s should be built. Not all ID subdetectors are set, but I'll set all of them up to capture the extra setup happening here.",
", ".join(subDetectors))
actsTrackingGeometrySvc = Acts_ActsTrackingGeometrySvc(
name, BuildSubDetectors=subDetectors)
from AthenaCommon.Constants import VERBOSE
actsTrackingGeometrySvc.OutputLevel = VERBOSE
result.addService(actsTrackingGeometrySvc)
return result
def reopen_fds(wkdir=""):
"""redirect workers fds by setting proper flags
<INPUT> -> duplicate fd in RDONLY mode
<OUTPUT> -> redirect fd to local output-copy w/ duplicate flags.
"""
_info("reopen_fds: in dir [%s]" % wkdir)
import os, fcntl
#from IoRegistry import IoRegistry as ioreg
_join = os.path.join
_fds = IoRegistry.fds_dict
_fds.create_symlinks(wkdir)
for k, v in _fds.iteritems():
fd = k;
(real_name, iomode, flags) = v
if not os.path.isfile (real_name):
_debug("reopen_fds: %s is not file" % real_name)
continue
if (iomode == '<OUTPUT>'):
#expect the copy of <OUTPUT> to be in curdir
_debug("reopen_fds: <OUTPUT> %s " % real_name)
pos = os.lseek(fd, 0, os.SEEK_CUR)
#PC HACK remove!
try:
new_fd = os.open (_join(wkdir, os.path.basename(real_name)), flags)
os.lseek(new_fd, pos, os.SEEK_SET)
except Exception, err:
msg.warning("Exception caught handling OUTPUT file %s: %s" % (real_name, err) )
msg.warning(" ...ignoring file FIXME!")
continue
else:
_debug("reopen_fds:<INPUT> %s" % real_name)
new_fd = os.open (real_name, os.O_RDONLY)
os.close (fd)
os.dup2 (new_fd, fd)
fcntl.fcntl (fd, fcntl.F_SETFL, flags)
os.close (new_fd)
def setupEvtSelForSeekOps():
""" try to install seek-stuff on the EventSelector side """
#import sys
#from AthenaCommon.Logging import log as msg
msg.debug("setupEvtSelForSeekOps:")
if sys.modules.has_key('AthenaRootComps.ReadAthenaRoot'):
# athenarootcomps has seeking enabled by default
msg.info('=> Seeking enabled.')
return
if not sys.modules.has_key('AthenaPoolCnvSvc.ReadAthenaPool'):
## user did not import that module so we give up
msg.info( "Cannot enable 'seeking' b/c module " + \
"[AthenaPoolCnvSvc.ReadAthenaPool] hasn't been imported..." )
msg.info( "Modify your jobOptions to import that module "+ \
"(or just ignore this message)" )
return
from AthenaCommon.AppMgr import theApp, AthAppMgr
if theApp.state() != AthAppMgr.State.OFFLINE:
msg.info( "C++ ApplicationMgr already instantiated, probably seeking "+\
"will be ill-configured..." )
msg.info( "EventSelector writers should implement updateHandlers" )
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaCommon.Configurable import Configurable
collectionType = svcMgr.EventSelector.properties()["CollectionType"]
if collectionType in ( "ImplicitROOT", Configurable.propertyNoValue, ):
svcMgr.EventSelector.CollectionType = "SeekableROOT"
msg.info ( "=> Seeking enabled." )
elif collectionType in ( "SeekableROOT", ):
msg.verbose( "=> Seeking already enabled." )
else:
msg.warning( "Input seeking is not compatible with collection type of %s",
svcMgr.EventSelector.properties()["CollectionType"] )
msg.warning( "=> Seeking disabled." )
return
def hack_copy(srcDir, destDir):
""" explicitly copy files not captured by IoRegistry"""
#couple of sanity checks
if srcDir == '':
srcDir = os.curdir
if srcDir == destDir:
msg.warning("hack_copy called with srcDir = destDir = "+srcDir)
return
#A hack for RDO reconstruction after nextEvent(n)
filepattern_list = [ 'DigitParams.db', 'SimParams.db',
'*.pmon.stream' ]
import fnmatch
import shutil
import os
for pattern in filepattern_list:
for f in os.listdir(srcDir):
if fnmatch.fnmatch(f, pattern):
import os.path
src_path = os.path.join(srcDir,f)
dest_path = os.path.join(destDir,f)
if not os.path.isfile(dest_path):
shutil.copyfile(src_path, dest_path)
def configureStrategy(self, strategy, pileup, events_before_fork):
from AthenaMPFlags import jobproperties as jp
from AthenaCommon.ConcurrencyFlags import jobproperties as jp
event_range_channel = jp.AthenaMPFlags.EventRangeChannel()
chunk_size = jp.AthenaMPFlags.ChunkSize()
debug_worker = jp.ConcurrencyFlags.DebugWorkers()
if strategy == 'SharedQueue' or strategy == 'RoundRobin':
from AthenaMPTools.AthenaMPToolsConf import SharedEvtQueueProvider
self.Tools += [
SharedEvtQueueProvider(IsPileup=pileup,
EventsBeforeFork=events_before_fork,
ChunkSize=chunk_size)
]
if (self.nThreads >= 1):
from AthenaMPTools.AthenaMPToolsConf import SharedHiveEvtQueueConsumer
self.Tools += [
SharedHiveEvtQueueConsumer(
UseSharedReader=False,
IsPileup=pileup,
IsRoundRobin=(strategy == 'RoundRobin'),
EventsBeforeFork=events_before_fork,
Debug=debug_worker)
]
else:
from AthenaMPTools.AthenaMPToolsConf import SharedEvtQueueConsumer
self.Tools += [
SharedEvtQueueConsumer(
UseSharedReader=False,
IsPileup=pileup,
IsRoundRobin=(strategy == 'RoundRobin'),
EventsBeforeFork=events_before_fork,
ReadEventOrders=jp.AthenaMPFlags.ReadEventOrders(),
EventOrdersFile=jp.AthenaMPFlags.EventOrdersFile(),
Debug=debug_worker)
]
# Enable seeking
setupEvtSelForSeekOps()
elif strategy == 'FileScheduling':
from AthenaMPTools.AthenaMPToolsConf import FileSchedulingTool
self.Tools += [
FileSchedulingTool(IsPileup=pileup, Debug=debug_worker)
]
elif strategy == 'SharedReader':
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaServices.AthenaServicesConf import AthenaSharedMemoryTool
shm_name = "EvtSelSM_" + str(os.getpid())
svcMgr.EventSelector.SharedMemoryTool = AthenaSharedMemoryTool(
"EventStreamingTool")
if sys.modules.has_key('AthenaPoolCnvSvc.ReadAthenaPool'):
svcMgr.AthenaPoolCnvSvc.DataStreamingTool = AthenaSharedMemoryTool(
"DataStreamingTool")
from AthenaMPTools.AthenaMPToolsConf import SharedReaderTool
self.Tools += [SharedReaderTool()]
from AthenaMPTools.AthenaMPToolsConf import SharedEvtQueueProvider
self.Tools += [
SharedEvtQueueProvider(IsPileup=pileup, EventsBeforeFork=0)
]
from AthenaMPTools.AthenaMPToolsConf import SharedEvtQueueConsumer
self.Tools += [
SharedEvtQueueConsumer(UseSharedReader=True,
IsPileup=pileup,
EventsBeforeFork=0)
]
elif strategy == 'EventService':
channelScatterer2Processor = "AthenaMP_Scatterer2Processor"
channelProcessor2EvtSel = "AthenaMP_Processor2EvtSel"
use_token_extractor = jp.AthenaMPFlags.UseTokenExtractor()
if use_token_extractor:
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaServices.AthenaServicesConf import AthenaYamplTool
svcMgr.EventSelector.SharedMemoryTool = AthenaYamplTool(
"AthenaYamplTool",
ChannelName=channelProcessor2EvtSel,
Many2One=False)
from AthenaMPTools.AthenaMPToolsConf import EvtRangeScatterer
self.Tools += [
EvtRangeScatterer(
ProcessorChannel=channelScatterer2Processor,
EventRangeChannel=event_range_channel,
UseTokenExtractor=use_token_extractor,
TokenExtractorChannel=jp.AthenaMPFlags.
TokenExtractorChannel(),
DoCaching=jp.AthenaMPFlags.EvtRangeScattererCaching())
]
from AthenaMPTools.AthenaMPToolsConf import EvtRangeProcessor
self.Tools += [
EvtRangeProcessor(IsPileup=pileup,
Channel2Scatterer=channelScatterer2Processor,
Channel2EvtSel=channelProcessor2EvtSel,
UseTokenExtractor=use_token_extractor,
Debug=debug_worker)
]
# Enable seeking
setupEvtSelForSeekOps()
else:
msg.warning("Unknown strategy. No MP tools will be configured")
def configureStrategy(self, strategy, pileup, events_before_fork):
from AthenaMPFlags import jobproperties as jp
from AthenaCommon.ConcurrencyFlags import jobproperties as jp
event_range_channel = jp.AthenaMPFlags.EventRangeChannel()
chunk_size = jp.AthenaMPFlags.ChunkSize()
debug_worker = jp.ConcurrencyFlags.DebugWorkers()
use_shared_reader = jp.AthenaMPFlags.UseSharedReader()
use_shared_writer = jp.AthenaMPFlags.UseSharedWriter()
if strategy == 'SharedQueue' or strategy == 'RoundRobin':
if use_shared_reader:
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaServices.AthenaServicesConf import AthenaSharedMemoryTool
svcMgr.EventSelector.SharedMemoryTool = AthenaSharedMemoryTool(
"EventStreamingTool")
if sys.modules.has_key('AthenaPoolCnvSvc.ReadAthenaPool'):
svcMgr.AthenaPoolCnvSvc.InputStreamingTool = AthenaSharedMemoryTool(
"InputStreamingTool")
if use_shared_writer:
if sys.modules.has_key('AthenaPoolCnvSvc.WriteAthenaPool'):
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaServices.AthenaServicesConf import AthenaSharedMemoryTool
svcMgr.AthenaPoolCnvSvc.OutputStreamingTool = [
AthenaSharedMemoryTool("OutputStreamingTool_0")
]
from AthenaMPTools.AthenaMPToolsConf import SharedEvtQueueProvider
self.Tools += [
SharedEvtQueueProvider(UseSharedReader=use_shared_reader,
IsPileup=pileup,
EventsBeforeFork=events_before_fork,
ChunkSize=chunk_size)
]
if (self.nThreads >= 1):
from AthenaMPTools.AthenaMPToolsConf import SharedHiveEvtQueueConsumer
self.Tools += [
SharedHiveEvtQueueConsumer(
UseSharedReader=use_shared_reader,
IsPileup=pileup,
IsRoundRobin=(strategy == 'RoundRobin'),
EventsBeforeFork=events_before_fork,
Debug=debug_worker)
]
else:
from AthenaMPTools.AthenaMPToolsConf import SharedEvtQueueConsumer
self.Tools += [
SharedEvtQueueConsumer(
UseSharedReader=use_shared_reader,
UseSharedWriter=use_shared_writer,
IsPileup=pileup,
IsRoundRobin=(strategy == 'RoundRobin'),
EventsBeforeFork=events_before_fork,
ReadEventOrders=jp.AthenaMPFlags.ReadEventOrders(),
EventOrdersFile=jp.AthenaMPFlags.EventOrdersFile(),
Debug=debug_worker)
]
if use_shared_writer:
from AthenaMPTools.AthenaMPToolsConf import SharedWriterTool
self.Tools += [SharedWriterTool()]
# Enable seeking
if not use_shared_reader:
setupEvtSelForSeekOps()
elif strategy == 'FileScheduling':
from AthenaMPTools.AthenaMPToolsConf import FileSchedulingTool
self.Tools += [
FileSchedulingTool(IsPileup=pileup, Debug=debug_worker)
]
elif strategy == 'EventService':
channelScatterer2Processor = "AthenaMP_Scatterer2Processor"
channelProcessor2EvtSel = "AthenaMP_Processor2EvtSel"
from AthenaMPTools.AthenaMPToolsConf import EvtRangeScatterer
self.Tools += [
EvtRangeScatterer(
ProcessorChannel=channelScatterer2Processor,
EventRangeChannel=event_range_channel,
DoCaching=jp.AthenaMPFlags.EvtRangeScattererCaching())
]
from AthenaMPTools.AthenaMPToolsConf import EvtRangeProcessor
self.Tools += [
EvtRangeProcessor(IsPileup=pileup,
Channel2Scatterer=channelScatterer2Processor,
Channel2EvtSel=channelProcessor2EvtSel,
Debug=debug_worker)
]
# Enable seeking
setupEvtSelForSeekOps()
else:
msg.warning("Unknown strategy. No MP tools will be configured")
# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
from .AthAnalysisToolsConf import *
from AthenaCommon.Logging import log as _msg
_msg.warning(' AnalysisTools.AnalysisToolsConf is DEPRECATED !')
_msg.warning('use AnalysisTools.AthAnalysisToolsConf instead')
def configureStrategy(self,strategy,pileup,events_before_fork):
from AthenaMPFlags import jobproperties as jp
from AthenaCommon.ConcurrencyFlags import jobproperties as jp
event_range_channel = jp.AthenaMPFlags.EventRangeChannel()
chunk_size = jp.AthenaMPFlags.ChunkSize()
debug_worker = jp.ConcurrencyFlags.DebugWorkers()
if strategy=='SharedQueue' or strategy=='RoundRobin':
from AthenaMPTools.AthenaMPToolsConf import SharedEvtQueueProvider
self.Tools += [ SharedEvtQueueProvider(IsPileup=pileup,
EventsBeforeFork=events_before_fork,
ChunkSize=chunk_size) ]
if (self.nThreads >= 1):
from AthenaMPTools.AthenaMPToolsConf import SharedHiveEvtQueueConsumer
self.Tools += [ SharedHiveEvtQueueConsumer(UseSharedReader=False,
IsPileup=pileup,
IsRoundRobin=(strategy=='RoundRobin'),
EventsBeforeFork=events_before_fork,
Debug=debug_worker) ]
else:
from AthenaMPTools.AthenaMPToolsConf import SharedEvtQueueConsumer
self.Tools += [ SharedEvtQueueConsumer(UseSharedReader=False,
IsPileup=pileup,
IsRoundRobin=(strategy=='RoundRobin'),
EventsBeforeFork=events_before_fork,
ReadEventOrders=jp.AthenaMPFlags.ReadEventOrders(),
EventOrdersFile=jp.AthenaMPFlags.EventOrdersFile(),
Debug=debug_worker) ]
# Enable seeking
setupEvtSelForSeekOps()
elif strategy=='FileScheduling':
from AthenaMPTools.AthenaMPToolsConf import FileSchedulingTool
self.Tools += [ FileSchedulingTool(IsPileup=pileup,
Debug=debug_worker) ]
elif strategy=='SharedReader':
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaServices.AthenaServicesConf import AthenaSharedMemoryTool
shm_name = "EvtSelSM_" + str(os.getpid())
svcMgr.EventSelector.SharedMemoryTool = AthenaSharedMemoryTool("EventStreamingTool")
if sys.modules.has_key('AthenaPoolCnvSvc.ReadAthenaPool'):
svcMgr.AthenaPoolCnvSvc.DataStreamingTool = AthenaSharedMemoryTool("DataStreamingTool")
from AthenaMPTools.AthenaMPToolsConf import SharedReaderTool
self.Tools += [ SharedReaderTool() ]
from AthenaMPTools.AthenaMPToolsConf import SharedEvtQueueProvider
self.Tools += [ SharedEvtQueueProvider(IsPileup=pileup,
EventsBeforeFork=0) ]
from AthenaMPTools.AthenaMPToolsConf import SharedEvtQueueConsumer
self.Tools += [ SharedEvtQueueConsumer(UseSharedReader=True,
IsPileup=pileup,
EventsBeforeFork=0) ]
elif strategy=='EventService':
channelScatterer2Processor = "AthenaMP_Scatterer2Processor"
channelProcessor2EvtSel = "AthenaMP_Processor2EvtSel"
use_token_extractor = jp.AthenaMPFlags.UseTokenExtractor()
if use_token_extractor:
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaServices.AthenaServicesConf import AthenaYamplTool
svcMgr.EventSelector.SharedMemoryTool = AthenaYamplTool("AthenaYamplTool",
ChannelName = channelProcessor2EvtSel,
Many2One=False)
from AthenaMPTools.AthenaMPToolsConf import EvtRangeScatterer
self.Tools += [ EvtRangeScatterer(ProcessorChannel = channelScatterer2Processor,
EventRangeChannel = event_range_channel,
UseTokenExtractor = use_token_extractor,
TokenExtractorChannel = jp.AthenaMPFlags.TokenExtractorChannel(),
DoCaching=jp.AthenaMPFlags.EvtRangeScattererCaching()) ]
from AthenaMPTools.AthenaMPToolsConf import EvtRangeProcessor
self.Tools += [ EvtRangeProcessor(IsPileup=pileup,
Channel2Scatterer = channelScatterer2Processor,
Channel2EvtSel = channelProcessor2EvtSel,
UseTokenExtractor = use_token_extractor,
Debug=debug_worker) ]
# Enable seeking
setupEvtSelForSeekOps()
else:
msg.warning("Unknown strategy. No MP tools will be configured")
def configureStrategy(self, strategy, pileup, events_before_fork):
from .AthenaMPFlags import jobproperties as jp
from AthenaCommon.ConcurrencyFlags import jobproperties as jp
event_range_channel = jp.AthenaMPFlags.EventRangeChannel()
if (jp.AthenaMPFlags.ChunkSize() > 0):
chunk_size = jp.AthenaMPFlags.ChunkSize()
msg.info('Chunk size set to %i', chunk_size)
#Use auto flush only if file is compressed with LZMA, else use default chunk_size
elif (jp.AthenaMPFlags.ChunkSize() == -1):
from PyUtils.MetaReaderPeeker import metadata
if (metadata['file_comp_alg'] == 2):
chunk_size = metadata['auto_flush']
msg.info('Chunk size set to auto flush (%i)', chunk_size)
else:
chunk_size = jp.AthenaMPFlags.ChunkSize.__class__.StoredValue
msg.info(
'LZMA algorithm not in use, chunk_size set to default (%i)',
chunk_size)
#Use auto flush only if file is compressed with LZMA or ZLIB, else use default chunk_size
elif (jp.AthenaMPFlags.ChunkSize() == -2):
from PyUtils.MetaReaderPeeker import metadata
if (metadata['file_comp_alg'] == 1
or metadata['file_comp_alg'] == 2):
chunk_size = metadata['auto_flush']
msg.info('Chunk size set to auto flush (%i)', chunk_size)
else:
chunk_size = jp.AthenaMPFlags.ChunkSize.__class__.StoredValue
msg.info(
'LZMA nor ZLIB in use, chunk_size set to default (%i)',
chunk_size)
#Use auto flush only if file is compressed with LZMA, ZLIB or LZ4, else use default chunk_size
elif (jp.AthenaMPFlags.ChunkSize() == -3):
from PyUtils.MetaReaderPeeker import metadata
if (metadata['file_comp_alg'] == 1
or metadata['file_comp_alg'] == 2
or metadata['file_comp_alg'] == 4):
chunk_size = metadata['auto_flush']
msg.info('Chunk size set to auto flush (%i)', chunk_size)
else:
chunk_size = jp.AthenaMPFlags.ChunkSize.__class__.StoredValue
msg.info(
'LZMA, ZLIB nor LZ4 in use, chunk_size set to default (%i)',
chunk_size)
#Use auto flush value for chunk_size, regarldess of compression algorithm
elif (jp.AthenaMPFlags.ChunkSize() <= -4):
from PyUtils.MetaReaderPeeker import metadata
chunk_size = metadata['auto_flush']
msg.info('Chunk size set to auto flush (%i)', chunk_size)
else:
chunk_size = jp.AthenaMPFlags.ChunkSize.__class__.StoredValue
msg.warning('Invalid ChunkSize, Chunk Size set to default (%i)',
chunk_size)
debug_worker = jp.ConcurrencyFlags.DebugWorkers()
use_shared_reader = jp.AthenaMPFlags.UseSharedReader()
use_shared_writer = jp.AthenaMPFlags.UseSharedWriter()
if strategy == 'SharedQueue' or strategy == 'RoundRobin':
if use_shared_reader:
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaIPCTools.AthenaIPCToolsConf import AthenaSharedMemoryTool
svcMgr.EventSelector.SharedMemoryTool = AthenaSharedMemoryTool(
"EventStreamingTool",
SharedMemoryName="EventStream" + str(os.getpid()))
if 'AthenaPoolCnvSvc.ReadAthenaPool' in sys.modules:
svcMgr.AthenaPoolCnvSvc.InputStreamingTool = AthenaSharedMemoryTool(
"InputStreamingTool",
SharedMemoryName="InputStream" + str(os.getpid()))
if use_shared_writer:
if 'AthenaPoolCnvSvc.WriteAthenaPool' in sys.modules:
from AthenaCommon.AppMgr import ServiceMgr as svcMgr
from AthenaIPCTools.AthenaIPCToolsConf import AthenaSharedMemoryTool
svcMgr.AthenaPoolCnvSvc.OutputStreamingTool += [
AthenaSharedMemoryTool(
"OutputStreamingTool_0",
SharedMemoryName="OutputStream" + str(os.getpid()))
]
from AthenaMPTools.AthenaMPToolsConf import SharedEvtQueueProvider
self.Tools += [
SharedEvtQueueProvider(UseSharedReader=use_shared_reader,
IsPileup=pileup,
EventsBeforeFork=events_before_fork,
ChunkSize=chunk_size)
]
if (self.nThreads >= 1):
from AthenaMPTools.AthenaMPToolsConf import SharedHiveEvtQueueConsumer
self.Tools += [
SharedHiveEvtQueueConsumer(
UseSharedReader=use_shared_reader,
IsPileup=pileup,
IsRoundRobin=(strategy == 'RoundRobin'),
EventsBeforeFork=events_before_fork,
Debug=debug_worker)
]
else:
from AthenaMPTools.AthenaMPToolsConf import SharedEvtQueueConsumer
self.Tools += [
SharedEvtQueueConsumer(
UseSharedReader=use_shared_reader,
UseSharedWriter=use_shared_writer,
IsPileup=pileup,
IsRoundRobin=(strategy == 'RoundRobin'),
EventsBeforeFork=events_before_fork,
ReadEventOrders=jp.AthenaMPFlags.ReadEventOrders(),
EventOrdersFile=jp.AthenaMPFlags.EventOrdersFile(),
Debug=debug_worker)
]
if use_shared_writer:
from AthenaMPTools.AthenaMPToolsConf import SharedWriterTool
self.Tools += [SharedWriterTool()]
# Enable seeking
if not use_shared_reader:
setupEvtSelForSeekOps()
elif strategy == 'FileScheduling':
from AthenaMPTools.AthenaMPToolsConf import FileSchedulingTool
self.Tools += [
FileSchedulingTool(IsPileup=pileup, Debug=debug_worker)
]
elif strategy == 'EventService':
channelScatterer2Processor = "AthenaMP_Scatterer2Processor"
channelProcessor2EvtSel = "AthenaMP_Processor2EvtSel"
from AthenaMPTools.AthenaMPToolsConf import EvtRangeScatterer
self.Tools += [
EvtRangeScatterer(
ProcessorChannel=channelScatterer2Processor,
EventRangeChannel=event_range_channel,
DoCaching=jp.AthenaMPFlags.EvtRangeScattererCaching())
]
from AthenaMPTools.AthenaMPToolsConf import EvtRangeProcessor
self.Tools += [
EvtRangeProcessor(IsPileup=pileup,
Channel2Scatterer=channelScatterer2Processor,
Channel2EvtSel=channelProcessor2EvtSel,
Debug=debug_worker)
]
# Enable seeking
setupEvtSelForSeekOps()
else:
msg.warning("Unknown strategy. No MP tools will be configured")
from AthenaCommon.AlgScheduler import AlgScheduler
AlgScheduler.OutputLevel( INFO )
AlgScheduler.ShowControlFlow( True )
AlgScheduler.ShowDataDependencies( True )
AlgScheduler.setDataLoaderAlg( 'SGInputLoader' )
# Support for the MT-MP hybrid mode
if (nProc > 0) :
from AthenaCommon.Logging import log as msg
if (theApp.EvtMax == -1) :
msg.fatal('EvtMax must be >0 for hybrid configuration')
sys.exit(AthenaCommon.ExitCodes.CONFIGURATION_ERROR)
if ( theApp.EvtMax % nProc != 0 ) :
msg.warning('EvtMax[%s] is not divisible by nProcs[%s]: MP Workers will not process all requested events',theApp.EvtMax,nProc)
chunkSize = int (theApp.EvtMax / nProc)
from AthenaMP.AthenaMPFlags import jobproperties as jps
jps.AthenaMPFlags.ChunkSize= chunkSize
msg.info('AthenaMP workers will process %s events each',chunkSize)
# MT-specific code
#---------------------------------------------------------------------------------#
theApp.EvtMax = 5
from xAODEventInfoCnv.xAODEventInfoCreator import xAODMaker__EventInfoCnvAlg
topSequence+=xAODMaker__EventInfoCnvAlg()
if args.dqOffByDefault:
from AthenaMonitoring.DQConfigFlags import allSteeringFlagsOff
allSteeringFlagsOff()
ConfigFlags.fillFromArgs(parser=parser)
# override Input.Files with result from our own arguments
# if --filesInput was specified as well (!) this will override
if args.inputFiles is not None:
ConfigFlags.Input.Files = args.inputFiles.split(',')
# if --evtMax was specified as well this will override
if args.maxEvents is not None:
ConfigFlags.Exec.MaxEvents = args.maxEvents
isReadingRaw = (GetFileMD(ConfigFlags.Input.Files).get(
'file_type', 'POOL') == 'BS')
if isReadingRaw:
if ConfigFlags.DQ.Environment not in ('tier0', 'tier0Raw', 'online'):
log.warning('Reading RAW file, but DQ.Environment set to %s',
ConfigFlags.DQ.Environment)
log.warning('Will proceed but best guess is this is an error')
log.info('Will schedule reconstruction, as best we know')
else:
if ConfigFlags.DQ.Environment in ('tier0', 'tier0Raw', 'online'):
log.warning('Reading POOL file, but DQ.Environment set to %s',
ConfigFlags.DQ.Environment)
log.warning('Will proceed but best guess is this is an error')
if args.preExec:
# bring things into scope
from AthenaMonitoring.DQConfigFlags import allSteeringFlagsOff
log.info('Executing preExec: %s', args.preExec)
exec(args.preExec)
if hasattr(ConfigFlags, "DQ") and hasattr(
