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 330 of file Main.py.

Constructor & Destructor Documentation

__init__()

def Gaudi.Main.gaudimain.__init__

(

self

)

Definition at line 331 of file Main.py.

    def __init__(self):
        from Configurables import ApplicationMgr
 
        appMgr = ApplicationMgr()
        if os.environ.get("GAUDIAPPNAME"):
            appMgr.AppName = str(os.environ["GAUDIAPPNAME"])
        if os.environ.get("GAUDIAPPVERSION"):
            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 407 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 400 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 381 of file Main.py.

    def generatePyOutput(self, all=False):
        from collections import defaultdict
        from pprint import pformat
 
        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 479 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 421 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 470 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 539 of file Main.py.

    def runParallel(self, ncpus):
        self.setupParallelLogging()
        import GaudiMP.GMPBase as gpp
        from Gaudi.Configuration import Configurable
 
        c = Configurable.allConfigurables
        self.log.info("-" * 80)
        self.log.info("%s: Parallel Mode : %i ", __name__, ncpus)
        for name, value in [
            ("platform", " ".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 497 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 343 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 432 of file Main.py.

    def writeconfig(self, filename, all=False):
        import json
 
        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"
            ),
            ".json": lambda filename, all: json.dump(
                getAllOpts(all), open(filename, "w"), indent=2, sort_keys=True
            ),
        }
        try:
            import yaml
 
            write[".yaml"] = lambda filename, all: yaml.safe_dump(
                getAllOpts(all), open(filename, "w")
            )
            write[".yml"] = write[".yaml"]
        except ImportError:
            pass  # yaml support is optional
 
        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, sorted(write.keys())
            )
            sys.exit(1)
 

Member Data Documentation

application

Gaudi.Main.gaudimain.application

Definition at line 341 of file Main.py.

log

Gaudi.Main.gaudimain.log

Definition at line 339 of file Main.py.

printsequence

Gaudi.Main.gaudimain.printsequence

Definition at line 340 of file Main.py.

---

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

• Gaudi/python/Gaudi/Main.py