Gaudi.Main.gaudimain Class Reference

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

Public Attributes
	log = logging.getLogger(__name__)
bool	printsequence = False
str	application = "Gaudi::Application"

Protected Member Functions
	_writepickle (self, filename)

Detailed Description

Definition at line 319 of file Main.py.

Constructor & Destructor Documentation

__init__()

Gaudi.Main.gaudimain.__init__

(

self

)

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

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

protected

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

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

Definition at line 385 of file Main.py.

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

generatePyOutput()

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

Definition at line 370 of file Main.py.

    def generatePyOutput(self, all=False):
        import re
        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))
        # undo splitting of strings on multiple lines
 
        return re.sub(r'"\n +"', "", formatted, flags=re.MULTILINE)
 

hookDebugger()

Gaudi.Main.gaudimain.hookDebugger

(

self

)

Hook gdb to the current session. This is done by forking
the current process and replacing the parent with gdb, while
the child continues to run the program.

Definition at line 462 of file Main.py.

    def hookDebugger(self):
        """Hook gdb to the current session. This is done by forking
        the current process and replacing the parent with gdb, while
        the child continues to run the program.
        """
 
        child_pid = os.fork()
 
        if child_pid == 0:
            # CHILD PROCESS - runs the actual program
            return
        else:
            # PARENT PROCESS - becomes GDB
 
            # Replace parent process with GDB
            args = [arg for arg in sys.argv if arg != "--gdb"]
            os.execvp(
                "gdb",
                [
                    "gdb",
                    "-q",
                    "-p",
                    str(child_pid),
                    "-ex",
                    f"set args {' '.join(args)}",
                ],
            )
 

printconfig()

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

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

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

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

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

Definition at line 532 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 Exception:
            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(f"MAIN.PY : received {sc} from Coordinator")
        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()

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

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

Gaudi.Main.gaudimain.setupParallelLogging

(

self

)

Definition at line 332 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(f"gaudirun-{datetime}.log", "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()

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

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

str Gaudi.Main.gaudimain.application = "Gaudi::Application"

Definition at line 330 of file Main.py.

log

Gaudi.Main.gaudimain.log = logging.getLogger(__name__)

Definition at line 328 of file Main.py.

printsequence

bool Gaudi.Main.gaudimain.printsequence = False

Definition at line 329 of file Main.py.

---

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

• Gaudi/python/Gaudi/Main.py