Preparation.py

Go to the documentation of this file.

import AthenaCommon.Include as AthCIncMod
if opts.showincludes:
   AthCIncMod.marker = ' -#-'      # distinguish bootstrap from other jo-code
 

if opts.interactive:
   from AthenaCommon.Interactive import configureInteractivePrompt
   configureInteractivePrompt()
   del configureInteractivePrompt
 

from AthenaCommon.Debugging import hookDebugger, allowPtrace
allowPtrace()
 

from AthenaCommon.Configurable import *
 

from AthenaCommon.Constants import *
# namespace these constants: Lvl.INFO
# so we can write e.g: Units.GeV
import AthenaCommon.Constants     as Lvl
import AthenaCommon.SystemOfUnits as Units
 

from AthenaCommon import CfgMgr
from AthenaCommon.AppMgr import ( athAlgSeq, theApp, ToolSvc, theAuditorSvc,
                                  ServiceMgr, ServiceMgr as svcMgr )
from AthenaCommon.Logging import log
 
# load all entries so far into the workspace of include()
 
if opts.interactive:                                 # i.e. interactive
   theApp.EventLoop = "PyAthenaEventLoopMgr"         # from AthenaServices
 

theApp.setOutputLevel( globals()[opts.loglevel] )
theApp._opts = opts                                     # FIXME
 

if not "POOL_OUTMSG_LEVEL" in os.environ:
   os.environ[ "POOL_OUTMSG_LEVEL" ] = str(globals()[opts.loglevel])
 

import AthenaCommon.AtlasUnixStandardJob
 
from PyUtils.Helpers import ROOTSetup
ROOTSetup(batch=not opts.interactive)
# Make sure that batch mode gets set properly.
# ROOTSetup will set things up so that whenever we do an `import ROOT',
# then gROOT.SetBatch will be called properly.
# However, if someone instead writes `from ROOT import gSystem'
# (or anything other than gROOT), then the ROOT python update thread
# will be started before ROOTSetup calls SetBatch.
# (This was then problematic for some MP jobs which used python
# algorithms.)
# So include the import here explictly to ensure that batch mode gets set.
# The following call to SetBatch is strictly redundant, but included
# for clarity.
import ROOT
ROOT.gROOT.SetBatch(not opts.interactive)
 
 

 

from AthenaCommon.Include import IncludeError
try:
   include( "$HOME/.athenarc" )
except IncludeError:
   pass
 

from AthenaCommon.ResourceLimits import SetMaxLimits
SetMaxLimits()
del SetMaxLimits
del sys.modules[ 'AthenaCommon.ResourceLimits' ]
 

if opts.interactive:
   import atexit
 
 # finalize on exit (^D)
   atexit.register( theApp.exit )
 
   del atexit
 
if opts.command:
   _msg.info( 'executing CLI (-c) command: "%s"' % opts.command )
   exec (opts.command)
 
if DbgStage.value == "conf":
   hookDebugger()
 
if opts.showincludes:
   AthCIncMod.marker = AthCIncMod.__marker__      # reset
del AthCIncMod
 
if opts.do_leak_chk:
   from Hephaestus.Auditor import HephaestusAuditor
   theApp.AuditAlgorithms = True
   svcMgr.AuditorSvc += HephaestusAuditor(
      mode = opts.memchk_mode, auditOn = opts.do_leak_chk )
 

 
from AthenaCommon.ConcurrencyFlags import jobproperties as jps
if opts.nprocs and (opts.nprocs >= 1 or opts.nprocs==-1):
   # MPI and AthenaMP don't mix
   if opts.mpi:
      _msg.error("Cannot run AthenaMP with MPI")
      sys.exit()
   jps.ConcurrencyFlags.NumProcs = opts.nprocs
   _msg.info ("configuring AthenaMP with [%s] sub-workers", 
              jps.ConcurrencyFlags.NumProcs())
 
   if (opts.debug_worker is True) :
      jps.ConcurrencyFlags.DebugWorkers = True
      _msg.info ("   Workers will pause after fork until SIGUSR1 signal received")
 
if (opts.threads or opts.concurrent_events) :
 
   if (opts.threads is None and opts.concurrent_events is not None) :
      
      jps.ConcurrencyFlags.NumThreads = opts.concurrent_events
      jps.ConcurrencyFlags.NumConcurrentEvents = opts.concurrent_events
   elif (opts.threads is not None and opts.concurrent_events is None) :
      
      jps.ConcurrencyFlags.NumThreads = opts.threads
      jps.ConcurrencyFlags.NumConcurrentEvents = opts.threads
   else :
      
      jps.ConcurrencyFlags.NumThreads = opts.threads
      jps.ConcurrencyFlags.NumConcurrentEvents = opts.concurrent_events
         
 
   if (jps.ConcurrencyFlags.NumProcs() > 0) :
      _msg.info ("configuring hybrid AthenaMP/AthenaMT with [%s] concurrent threads and [%s] concurrent events per AthenaMP worker", jps.ConcurrencyFlags.NumThreads, jps.ConcurrencyFlags.NumConcurrentEvents)
   elif (jps.ConcurrencyFlags.NumProcs() == 0) :
      _msg.info ("configuring AthenaHive with [%s] concurrent threads and [%s] concurrent events", jps.ConcurrencyFlags.NumThreads(), jps.ConcurrencyFlags.NumConcurrentEvents())
   else:
      # we should never get here
      _msg.error ("ConcurrencyFlags.NumProcs() cannot == -1 !!")
      sys.exit()
 
   import AthenaCommon.AtlasThreadedJob