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	basicInit (self)
def	gaudiPythonInit (self)
def	runSerial (self, attach_debugger)
def	runParallel (self, ncpus)

Public Attributes
	log
	printsequence
	ip
	g

Static Public Attributes
	mainLoop = None

Private Member Functions
def	_writepickle (self, filename)

Detailed Description

Definition at line 163 of file Main.py.

Constructor & Destructor Documentation

def Gaudi.Main.gaudimain.__init__

(

self

)

Definition at line 167 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

Member Function Documentation

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

private

Definition at line 230 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()

def Gaudi.Main.gaudimain.basicInit

(

self

)

Bootstrap the application with minimal use of Python bindings.

Definition at line 293 of file Main.py.

    def basicInit(self):
        '''
        Bootstrap the application with minimal use of Python bindings.
        '''
        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, getNeededConfigurables

        global _bootstrap
        if _bootstrap is None:
            _bootstrap = BootstrapHelper()

        self.log.debug('basicInit: instantiate ApplicationMgr')
        self.ip = self.g = _bootstrap.createApplicationMgr()

        self.log.debug('basicInit: apply options')

        # set ApplicationMgr properties
        comp = 'ApplicationMgr'
        props = Configurable.allConfigurables.get(comp, {})
        if props:
            props = expandvars(props.getValuedProperties())
        for p, v in props.items() + [('JobOptionsType', 'NONE')]:
            if not self.g.setProperty(p, str(v)):
                self.log.error('Cannot set property %s.%s to %s', comp, p, v)
                sys.exit(10)
        # issue with missing dictionary with ROOT < 6.2.7
        if _bootstrap.ROOT_VERSION < (6, 2, 7):
            # we need to load GaudiPython
            import GaudiPython

        self.g.configure()

        # set MessageSvc properties
        comp = 'MessageSvc'
        msp = self.g.getService(comp)
        if not msp:
            self.log.error('Cannot get service %s', comp)
            sys.exit(10)
        props = Configurable.allConfigurables.get(comp, {})
        if props:
            props = expandvars(props.getValuedProperties())
        for p, v in props.items():
            if not _bootstrap.setProperty(msp, p, str(v)):
                self.log.error('Cannot set property %s.%s to %s', comp, p, v)
                sys.exit(10)

        # feed JobOptionsSvc
        comp = 'JobOptionsSvc'
        jos = self.g.getService(comp)
        if not jos:
            self.log.error('Cannot get service %s', comp)
            sys.exit(10)
        for n in getNeededConfigurables():
            c = Configurable.allConfigurables[n]
            if n in ['ApplicationMgr', 'MessageSvc']:
                continue  # These are already done
            for p, v in c.getValuedProperties().items():
                v = expandvars(v)
                # Note: AthenaCommon.Configurable does not have Configurable.PropertyReference
                if hasattr(Configurable, "PropertyReference") and type(v) == Configurable.PropertyReference:
                    # this is done in "getFullName", but the exception is ignored,
                    # so we do it again to get it
                    v = v.__resolve__()
                if type(v) == str:
                    v = '"%s"' % v  # need double quotes
                elif type(v) == long:
                    v = '%d' % v  # prevent pending 'L'
                _bootstrap.addPropertyToCatalogue(jos, n, p, str(v))
        if hasattr(Configurable, "_configurationLocked"):
            Configurable._configurationLocked = True
        self.log.debug('basicInit: done')

def Gaudi.Main.gaudimain.gaudiPythonInit

(

self

)

Initialize the application with full Python bindings.

Definition at line 370 of file Main.py.

    def gaudiPythonInit(self):
        '''
        Initialize the application with full Python bindings.
        '''
        self.log.debug('gaudiPythonInit: import GaudiPython')
        import GaudiPython
        self.log.debug('gaudiPythonInit: instantiate ApplicationMgr')
        self.g = GaudiPython.AppMgr()
        self.ip = self.g._ip
        self.log.debug('gaudiPythonInit: done')

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

Definition at line 217 of file Main.py.

    def generateOptsOutput(self, all=False):
        from pprint import pformat
        conf_dict = Configuration.configurationDict(all)
        out = []
        names = conf_dict.keys()
        names.sort()
        for n in names:
            props = conf_dict[n].keys()
            props.sort()
            for p in props:
                out.append('%s.%s = %s;' % (n, p, toOpt(conf_dict[n][p])))
        return "\n".join(out)

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

Definition at line 212 of file Main.py.

    def generatePyOutput(self, all=False):
        from pprint import pformat
        conf_dict = Configuration.configurationDict(all)
        return pformat(conf_dict)

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

Definition at line 278 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

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

Definition at line 242 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)
        conf_dict = Configuration.configurationDict(all)
        if old_format:
            print self.generateOptsOutput(all)
        else:
            print self.generatePyOutput(all)

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

Definition at line 269 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

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

Definition at line 452 of file Main.py.

    def runParallel(self, ncpus):
        if self.mainLoop:
            self.log.fatal(
                "Cannot use custom main loop in multi-process mode, check your options")
            return 1
        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

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

Definition at line 381 of file Main.py.

    def runSerial(self, attach_debugger):
        #--- Instantiate the ApplicationMgr------------------------------
        if (self.mainLoop or
                os.environ.get('GAUDIRUN_USE_GAUDIPYTHON')):
            self.gaudiPythonInit()
        else:
            self.basicInit()

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

        if self.mainLoop:
            runner = self.mainLoop
        else:
            def runner(app, nevt):
                self.log.debug('initialize')
                sc = app.initialize()
                if sc.isSuccess():
                    if self.printsequence:
                        app.printAlgsSequences()
                    self.log.debug('start')
                    sc = app.start()
                    if sc.isSuccess():
                        self.log.debug('run(%d)', nevt)
                        sc = app.run(nevt)
                        self.log.debug('stop')
                        app.stop().ignore()
                    self.log.debug('finalize')
                    app.finalize().ignore()
                self.log.debug('terminate')
                sc1 = app.terminate()
                if sc.isSuccess():
                    sc = sc1
                else:
                    sc1.ignore()
                self.log.debug('status code: %s',
                               'SUCCESS' if sc.isSuccess() else 'FAILURE')
                return sc

        if (attach_debugger == True):
            self.hookDebugger()

        try:
            statuscode = runner(self.g, int(
                self.ip.getProperty('EvtMax').toString()))
        except SystemError:
            # It may not be 100% correct, but usually it means a segfault in C++
            self.ip.setProperty('ReturnCode', str(128 + 11))
            statuscode = False
        except Exception, x:
            print 'Exception:', x
            # for other exceptions, just set a generic error code
            self.ip.setProperty('ReturnCode', '1')
            statuscode = False
        if hasattr(statuscode, "isSuccess"):
            success = statuscode.isSuccess()
        else:
            success = statuscode
        #success = self.g.exit().isSuccess() and success
        if not success and self.ip.getProperty('ReturnCode').toString() == '0':
            # ensure that the return code is correctly set
            self.ip.setProperty('ReturnCode', '1')
        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 int(self.ip.getProperty('ReturnCode').toString())

def Gaudi.Main.gaudimain.setupParallelLogging

(

self

)

Definition at line 177 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
        # ---------------------------------------------------

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

Definition at line 253 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

Gaudi.Main.gaudimain.g

Definition at line 310 of file Main.py.

Gaudi.Main.gaudimain.ip

Definition at line 310 of file Main.py.

Gaudi.Main.gaudimain.log

Definition at line 174 of file Main.py.

Gaudi.Main.gaudimain.mainLoop = None

static

Definition at line 165 of file Main.py.

Gaudi.Main.gaudimain.printsequence

Definition at line 175 of file Main.py.

---

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

• Gaudi/python/Gaudi/Main.py