Gaudi.Main.gaudimain Class Reference

Inheritance diagram for Gaudi.Main.gaudimain:

Collaboration diagram for Gaudi.Main.gaudimain:

Public Member Functions
def	__init__ (self)
def	setupParallelLogging (self)
def	generatePyOutput (self, all=False)
def	generateOptsOutput (self, all=False)
def	printconfig (self, old_format=False, all=False)
def	writeconfig (self, filename, all=False)
def	run (self, attach_debugger, ncpus=None)
def	hookDebugger (self, debugger='gdb')
def	runSerial (self, attach_debugger)
def	runParallel (self, ncpus)

Public Attributes
	log
	printsequence
	application

Private Member Functions
def	_writepickle (self, filename)

Detailed Description

Definition at line 282 of file Main.py.

Constructor & Destructor Documentation

__init__()

def Gaudi.Main.gaudimain.__init__

(

self

)

Definition at line 283 of file Main.py.

    def __init__(self):
        from Configurables import ApplicationMgr
        appMgr = ApplicationMgr()
        if "GAUDIAPPNAME" in os.environ:
            appMgr.AppName = str(os.environ["GAUDIAPPNAME"])
        if "GAUDIAPPVERSION" in os.environ:
            appMgr.AppVersion = str(os.environ["GAUDIAPPVERSION"])
        self.log = logging.getLogger(__name__)
        self.printsequence = False
        self.application = 'Gaudi::Application'

Member Function Documentation

_writepickle()

def Gaudi.Main.gaudimain._writepickle (   self,   filename  )

private

Definition at line 352 of file Main.py.

    def _writepickle(self, filename):
        # --- Lets take the first file input file as the name of the pickle file
        import pickle
        output = open(filename, 'wb')
        # Dump only the the configurables that make sense to dump (not User ones)
        from GaudiKernel.Proxy.Configurable import getNeededConfigurables
        to_dump = {}
        for n in getNeededConfigurables():
            to_dump[n] = Configuration.allConfigurables[n]
        pickle.dump(to_dump, output, -1)
        output.close()

generateOptsOutput()

def Gaudi.Main.gaudimain.generateOptsOutput	(		self,
			all = False
	)

Definition at line 346 of file Main.py.

    def generateOptsOutput(self, all=False):
        opts = getAllOpts(all)
        keys = sorted(opts)
        return '\n'.join(
            '{} = {};'.format(key, toOpt(parseOpt(opts[key]))) for key in keys)

generatePyOutput()

def Gaudi.Main.gaudimain.generatePyOutput	(		self,
			all = False
	)

Definition at line 329 of file Main.py.

    def generatePyOutput(self, all=False):
        from pprint import pformat
        from collections import defaultdict
        optDict = defaultdict(dict)
        allOpts = getAllOpts(all)
        for key in allOpts:
            c, p = key.rsplit('.', 1)
            optDict[c][p] = parseOpt(allOpts[key])
        formatted = pformat(dict(optDict))
        # Python 2 compatibility
        if six.PY2:
            return formatted
        else:
            # undo splitting of strings on multiple lines
            import re
            return re.sub(r'"\n +"', '', formatted, flags=re.MULTILINE)

hookDebugger()

def Gaudi.Main.gaudimain.hookDebugger	(		self,
			debugger = 'gdb'
	)

Definition at line 400 of file Main.py.

    def hookDebugger(self, debugger='gdb'):
        import os
        self.log.info('attaching debugger to PID ' + str(os.getpid()))
        pid = os.spawnvp(os.P_NOWAIT, debugger,
                         [debugger, '-q', 'python',
                          str(os.getpid())])

        # give debugger some time to attach to the python process
        import time
        time.sleep(5)

        # verify the process' existence (will raise OSError if failed)
        os.waitpid(pid, os.WNOHANG)
        os.kill(pid, 0)
        return

printconfig()

def Gaudi.Main.gaudimain.printconfig	(		self,
			old_format = False,
			all = False
	)

Definition at line 364 of file Main.py.

    def printconfig(self, old_format=False, all=False):
        msg = 'Dumping all configurables and properties'
        if not all:
            msg += ' (different from default)'
        log.info(msg)
        if old_format:
            print(self.generateOptsOutput(all))
        else:
            print(self.generatePyOutput(all))
        sys.stdout.flush()

run()

def Gaudi.Main.gaudimain.run	(		self,
			attach_debugger,
			ncpus = None
	)

Definition at line 391 of file Main.py.

    def run(self, attach_debugger, ncpus=None):
        if not ncpus:
            # Standard sequential mode
            result = self.runSerial(attach_debugger)
        else:
            # Otherwise, run with the specified number of cpus
            result = self.runParallel(ncpus)
        return result

runParallel()

def Gaudi.Main.gaudimain.runParallel	(		self,
			ncpus
	)

Definition at line 456 of file Main.py.

    def runParallel(self, ncpus):
        self.setupParallelLogging()
        from Gaudi.Configuration import Configurable
        import GaudiMP.GMPBase as gpp
        c = Configurable.allConfigurables
        self.log.info('-' * 80)
        self.log.info('%s: Parallel Mode : %i ', __name__, ncpus)
        for name, value in [
            ('platrofm', ' '.join(os.uname())),
            ('config', os.environ.get('BINARY_TAG')
             or os.environ.get('CMTCONFIG')),
            ('app. name', os.environ.get('GAUDIAPPNAME')),
            ('app. version', os.environ.get('GAUDIAPPVERSION')),
        ]:
            self.log.info('%s: %30s : %s ', __name__, name, value
                          or 'Undefined')
        try:
            events = str(c['ApplicationMgr'].EvtMax)
        except:
            events = "Undetermined"
        self.log.info('%s: Events Specified : %s ', __name__, events)
        self.log.info('-' * 80)
        # Parall = gpp.Coordinator(ncpus, shared, c, self.log)
        Parall = gpp.Coord(ncpus, c, self.log)
        sysStart = time()
        sc = Parall.Go()
        self.log.info('MAIN.PY : received %s from Coordinator' % (sc))
        if sc.isFailure():
            return 1
        sysTime = time() - sysStart
        self.log.name = 'Gaudi/Main.py Logger'
        self.log.info('-' * 80)
        self.log.info('%s: parallel system finished, time taken: %5.4fs',
                      __name__, sysTime)
        self.log.info('-' * 80)
        return 0

runSerial()

def Gaudi.Main.gaudimain.runSerial	(		self,
			attach_debugger
	)

Definition at line 416 of file Main.py.

    def runSerial(self, attach_debugger):
        try:
            from GaudiKernel.Proxy.Configurable import expandvars
        except ImportError:
            # pass-through implementation if expandvars is not defined (AthenaCommon)
            def expandvars(data):
                return data

        from GaudiKernel.Proxy.Configurable import Configurable

        self.log.debug('runSerial: apply options')
        conf_dict = expandvars(getAllOpts())
        conf_dict['ApplicationMgr.JobOptionsType'] = '"NONE"'

        if self.printsequence:
            conf_dict['ApplicationMgr.PrintAlgsSequence'] = 'true'

        if hasattr(Configurable, "_configurationLocked"):
            Configurable._configurationLocked = True

        if attach_debugger:
            self.hookDebugger()

        self.log.debug('-' * 80)
        self.log.debug('%s: running in serial mode', __name__)
        self.log.debug('-' * 80)
        sysStart = time()

        import Gaudi
        app = Gaudi.Application.create(self.application, conf_dict)
        retcode = app.run()

        sysTime = time() - sysStart
        self.log.debug('-' * 80)
        self.log.debug('%s: serial system finished, time taken: %5.4fs',
                       __name__, sysTime)
        self.log.debug('-' * 80)

        return retcode

setupParallelLogging()

def Gaudi.Main.gaudimain.setupParallelLogging

(

self

)

Definition at line 294 of file Main.py.

    def setupParallelLogging(self):
        # ---------------------------------------------------
        # set up Logging
        # ----------------
        # from multiprocessing import enableLogging, getLogger
        import multiprocessing
        # preliminaries for handlers/output files, etc.
        from time import ctime
        datetime = ctime()
        datetime = datetime.replace(' ', '_')
        outfile = open('gaudirun-%s.log' % (datetime), 'w')
        # two handlers, one for a log file, one for terminal
        streamhandler = logging.StreamHandler(stream=outfile)
        console = logging.StreamHandler()
        # create formatter : the params in parentheses are variable names available via logging
        formatter = logging.Formatter(
            "%(asctime)s - %(name)s - %(levelname)s - %(message)s")
        # add formatter to Handler
        streamhandler.setFormatter(formatter)
        console.setFormatter(formatter)
        # now, configure the logger
        # enableLogging( level=0 )
        # self.log = getLogger()
        self.log = multiprocessing.log_to_stderr()
        self.log.setLevel(logging.INFO)
        self.log.name = 'Gaudi/Main.py Logger'
        self.log.handlers = []
        # add handlers to logger : one for output to a file, one for console output
        self.log.addHandler(streamhandler)
        self.log.addHandler(console)
        self.log.removeHandler(console)
        # set level!!
        self.log.setLevel = logging.INFO
        # ---------------------------------------------------

writeconfig()

def Gaudi.Main.gaudimain.writeconfig	(		self,
			filename,
			all = False
	)

Definition at line 375 of file Main.py.

    def writeconfig(self, filename, all=False):
        write = {".pkl": lambda filename, all: self._writepickle(filename),
                 ".py": lambda filename, all: open(filename, "w").write(self.generatePyOutput(all) + "\n"),
                 ".opts": lambda filename, all: open(filename, "w").write(self.generateOptsOutput(all) + "\n"),
                 }
        from os.path import splitext
        ext = splitext(filename)[1]
        if ext in write:
            write[ext](filename, all)
        else:
            log.error("Unknown file type '%s'. Must be any of %r.", ext,
                      write.keys())
            sys.exit(1)

Member Data Documentation

application

Gaudi.Main.gaudimain.application

Definition at line 292 of file Main.py.

log

Gaudi.Main.gaudimain.log

Definition at line 290 of file Main.py.

printsequence

Gaudi.Main.gaudimain.printsequence

Definition at line 291 of file Main.py.

---

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

• Gaudi/python/Gaudi/Main.py