| # Copyright (c) 2016, 2019 Arm Limited |
| # All rights reserved. |
| # |
| # The license below extends only to copyright in the software and shall |
| # not be construed as granting a license to any other intellectual |
| # property including but not limited to intellectual property relating |
| # to a hardware implementation of the functionality of the software |
| # licensed hereunder. You may use the software subject to the license |
| # terms below provided that you ensure that this notice is replicated |
| # unmodified and in its entirety in all distributions of the software, |
| # modified or unmodified, in source code or in binary form. |
| # |
| # Copyright (c) 2005 The Regents of The University of Michigan |
| # All rights reserved. |
| # |
| # Redistribution and use in source and binary forms, with or without |
| # modification, are permitted provided that the following conditions are |
| # met: redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer; |
| # redistributions in binary form must reproduce the above copyright |
| # notice, this list of conditions and the following disclaimer in the |
| # documentation and/or other materials provided with the distribution; |
| # neither the name of the copyright holders nor the names of its |
| # contributors may be used to endorse or promote products derived from |
| # this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| # |
| # Authors: Nathan Binkert |
| |
| from __future__ import print_function |
| |
| import code |
| import datetime |
| import os |
| import socket |
| import sys |
| |
| __all__ = [ 'options', 'arguments', 'main' ] |
| |
| usage="%prog [gem5 options] script.py [script options]" |
| version="%prog 2.0" |
| brief_copyright=\ |
| "gem5 is copyrighted software; use the --copyright option for details." |
| |
| def _stats_help(option, opt, value, parser): |
| import m5 |
| print("A stat file can either be specified as a URI or a plain") |
| print("path. When specified as a path, gem5 uses the default text ") |
| print("format.") |
| print() |
| print("The following stat formats are supported:") |
| print() |
| m5.stats.printStatVisitorTypes() |
| sys.exit(0) |
| |
| |
| def parse_options(): |
| from . import config |
| from .options import OptionParser |
| |
| options = OptionParser(usage=usage, version=version, |
| description=brief_copyright) |
| option = options.add_option |
| group = options.set_group |
| |
| listener_modes = ( "on", "off", "auto" ) |
| |
| # Help options |
| option('-B', "--build-info", action="store_true", default=False, |
| help="Show build information") |
| option('-C', "--copyright", action="store_true", default=False, |
| help="Show full copyright information") |
| option('-R', "--readme", action="store_true", default=False, |
| help="Show the readme") |
| |
| # Options for configuring the base simulator |
| option('-d', "--outdir", metavar="DIR", default="m5out", |
| help="Set the output directory to DIR [Default: %default]") |
| option('-r', "--redirect-stdout", action="store_true", default=False, |
| help="Redirect stdout (& stderr, without -e) to file") |
| option('-e', "--redirect-stderr", action="store_true", default=False, |
| help="Redirect stderr to file") |
| option("--stdout-file", metavar="FILE", default="simout", |
| help="Filename for -r redirection [Default: %default]") |
| option("--stderr-file", metavar="FILE", default="simerr", |
| help="Filename for -e redirection [Default: %default]") |
| option("--listener-mode", metavar="{on,off,auto}", |
| choices=listener_modes, default="auto", |
| help="Port (e.g., gdb) listener mode (auto: Enable if running " \ |
| "interactively) [Default: %default]") |
| option("--listener-loopback-only", action="store_true", default=False, |
| help="Port listeners will only accept connections over the " \ |
| "loopback device") |
| option('-i', "--interactive", action="store_true", default=False, |
| help="Invoke the interactive interpreter after running the script") |
| option("--pdb", action="store_true", default=False, |
| help="Invoke the python debugger before running the script") |
| option('-p', "--path", metavar="PATH[:PATH]", action='append', split=':', |
| help="Prepend PATH to the system path when invoking the script") |
| option('-q', "--quiet", action="count", default=0, |
| help="Reduce verbosity") |
| option('-v', "--verbose", action="count", default=0, |
| help="Increase verbosity") |
| |
| # Statistics options |
| group("Statistics Options") |
| option("--stats-file", metavar="FILE", default="stats.txt", |
| help="Sets the output file for statistics [Default: %default]") |
| option("--stats-help", |
| action="callback", callback=_stats_help, |
| help="Display documentation for available stat visitors") |
| |
| # Configuration Options |
| group("Configuration Options") |
| option("--dump-config", metavar="FILE", default="config.ini", |
| help="Dump configuration output file [Default: %default]") |
| option("--json-config", metavar="FILE", default="config.json", |
| help="Create JSON output of the configuration [Default: %default]") |
| option("--dot-config", metavar="FILE", default="config.dot", |
| help="Create DOT & pdf outputs of the configuration [Default: %default]") |
| option("--dot-dvfs-config", metavar="FILE", default=None, |
| help="Create DOT & pdf outputs of the DVFS configuration" + \ |
| " [Default: %default]") |
| |
| # Debugging options |
| group("Debugging Options") |
| option("--debug-break", metavar="TICK[,TICK]", action='append', split=',', |
| help="Create breakpoint(s) at TICK(s) " \ |
| "(kills process if no debugger attached)") |
| option("--debug-help", action='store_true', |
| help="Print help on debug flags") |
| option("--debug-flags", metavar="FLAG[,FLAG]", action='append', split=',', |
| help="Sets the flags for debug output (-FLAG disables a flag)") |
| option("--debug-start", metavar="TICK", type='int', |
| help="Start debug output at TICK") |
| option("--debug-end", metavar="TICK", type='int', |
| help="End debug output at TICK") |
| option("--debug-file", metavar="FILE", default="cout", |
| help="Sets the output file for debug [Default: %default]") |
| option("--debug-ignore", metavar="EXPR", action='append', split=':', |
| help="Ignore EXPR sim objects") |
| option("--remote-gdb-port", type='int', default=7000, |
| help="Remote gdb base port (set to 0 to disable listening)") |
| |
| # Help options |
| group("Help Options") |
| option("--list-sim-objects", action='store_true', default=False, |
| help="List all built-in SimObjects, their params and default values") |
| |
| # load the options.py config file to allow people to set their own |
| # default options |
| options_file = config.get('options.py') |
| if options_file: |
| scope = { 'options' : options } |
| exec(compile(open(options_file).read(), options_file, 'exec'), scope) |
| |
| arguments = options.parse_args() |
| return options,arguments |
| |
| def interact(scope): |
| banner = "gem5 Interactive Console" |
| |
| ipshell = None |
| prompt_in1 = "gem5 \\#> " |
| prompt_out = "gem5 \\#: " |
| |
| # Is IPython version 0.10 or earlier available? |
| try: |
| from IPython.Shell import IPShellEmbed |
| ipshell = IPShellEmbed(argv=["-prompt_in1", prompt_in1, |
| "-prompt_out", prompt_out], |
| banner=banner, user_ns=scope) |
| except ImportError: |
| pass |
| |
| # Is IPython version 0.11 or later available? |
| if not ipshell: |
| try: |
| import IPython |
| from IPython.config.loader import Config |
| from IPython.terminal.embed import InteractiveShellEmbed |
| |
| cfg = Config() |
| cfg.PromptManager.in_template = prompt_in1 |
| cfg.PromptManager.out_template = prompt_out |
| ipshell = InteractiveShellEmbed(config=cfg, user_ns=scope, |
| banner1=banner) |
| except ImportError: |
| pass |
| |
| if ipshell: |
| ipshell() |
| else: |
| # Use the Python shell in the standard library if IPython |
| # isn't available. |
| code.InteractiveConsole(scope).interact(banner) |
| |
| |
| def _check_tracing(): |
| from . import defines |
| |
| if defines.TRACING_ON: |
| return |
| |
| fatal("Tracing is not enabled. Compile with TRACING_ON") |
| |
| def main(*args): |
| import m5 |
| |
| from . import core |
| from . import debug |
| from . import defines |
| from . import event |
| from . import info |
| from . import stats |
| from . import trace |
| |
| from .util import inform, fatal, panic, isInteractive |
| from m5.util.terminal_formatter import TerminalFormatter |
| |
| if len(args) == 0: |
| options, arguments = parse_options() |
| elif len(args) == 2: |
| options, arguments = args |
| else: |
| raise TypeError("main() takes 0 or 2 arguments (%d given)" % len(args)) |
| |
| m5.options = options |
| |
| # Set the main event queue for the main thread. |
| event.mainq = event.getEventQueue(0) |
| event.setEventQueue(event.mainq) |
| |
| if not os.path.isdir(options.outdir): |
| os.makedirs(options.outdir) |
| |
| # These filenames are used only if the redirect_std* options are set |
| stdout_file = os.path.join(options.outdir, options.stdout_file) |
| stderr_file = os.path.join(options.outdir, options.stderr_file) |
| |
| # Print redirection notices here before doing any redirection |
| if options.redirect_stdout and not options.redirect_stderr: |
| print("Redirecting stdout and stderr to", stdout_file) |
| else: |
| if options.redirect_stdout: |
| print("Redirecting stdout to", stdout_file) |
| if options.redirect_stderr: |
| print("Redirecting stderr to", stderr_file) |
| |
| # Now redirect stdout/stderr as desired |
| if options.redirect_stdout: |
| redir_fd = os.open(stdout_file, os. O_WRONLY | os.O_CREAT | os.O_TRUNC) |
| os.dup2(redir_fd, sys.stdout.fileno()) |
| if not options.redirect_stderr: |
| os.dup2(redir_fd, sys.stderr.fileno()) |
| |
| if options.redirect_stderr: |
| redir_fd = os.open(stderr_file, os. O_WRONLY | os.O_CREAT | os.O_TRUNC) |
| os.dup2(redir_fd, sys.stderr.fileno()) |
| |
| done = False |
| |
| if options.build_info: |
| done = True |
| print('Build information:') |
| print() |
| print('compiled %s' % defines.compileDate) |
| print('build options:') |
| keys = list(defines.buildEnv.keys()) |
| keys.sort() |
| for key in keys: |
| val = defines.buildEnv[key] |
| print(' %s = %s' % (key, val)) |
| print() |
| |
| if options.copyright: |
| done = True |
| print(info.COPYING) |
| print() |
| |
| if options.readme: |
| done = True |
| print('Readme:') |
| print() |
| print(info.README) |
| print() |
| |
| if options.debug_help: |
| done = True |
| _check_tracing() |
| debug.help() |
| |
| if options.list_sim_objects: |
| from . import SimObject |
| done = True |
| print("SimObjects:") |
| objects = list(SimObject.allClasses.keys()) |
| objects.sort() |
| terminal_formatter = TerminalFormatter() |
| for name in objects: |
| obj = SimObject.allClasses[name] |
| print(terminal_formatter.format_output(str(obj), indent=4)) |
| params = list(obj._params.keys()) |
| params.sort() |
| for pname in params: |
| param = obj._params[pname] |
| default = getattr(param, 'default', '') |
| print(terminal_formatter.format_output(pname, indent=8)) |
| if default: |
| print(terminal_formatter.format_output( |
| str(default), label="default: ", indent=21)) |
| print(terminal_formatter.format_output( |
| param.desc, label="desc: ", indent=21)) |
| print() |
| print() |
| |
| if done: |
| sys.exit(0) |
| |
| # setting verbose and quiet at the same time doesn't make sense |
| if options.verbose > 0 and options.quiet > 0: |
| options.usage(2) |
| |
| verbose = options.verbose - options.quiet |
| if verbose >= 0: |
| print("gem5 Simulator System. http://gem5.org") |
| print(brief_copyright) |
| print() |
| |
| print("gem5 compiled %s" % defines.compileDate) |
| |
| print("gem5 started %s" % |
| datetime.datetime.now().strftime("%b %e %Y %X")) |
| print("gem5 executing on %s, pid %d" % |
| (socket.gethostname(), os.getpid())) |
| |
| # in Python 3 pipes.quote() is moved to shlex.quote() |
| import pipes |
| print("command line:", " ".join(map(pipes.quote, sys.argv))) |
| print() |
| |
| # check to make sure we can find the listed script |
| if not arguments or not os.path.isfile(arguments[0]): |
| if arguments and not os.path.isfile(arguments[0]): |
| print("Script %s not found" % arguments[0]) |
| |
| options.usage(2) |
| |
| # tell C++ about output directory |
| core.setOutputDir(options.outdir) |
| |
| # update the system path with elements from the -p option |
| sys.path[0:0] = options.path |
| |
| # set stats options |
| stats.addStatVisitor(options.stats_file) |
| |
| # Disable listeners unless running interactively or explicitly |
| # enabled |
| if options.listener_mode == "off": |
| m5.disableAllListeners() |
| elif options.listener_mode == "auto": |
| if not isInteractive(): |
| inform("Standard input is not a terminal, disabling listeners.") |
| m5.disableAllListeners() |
| elif options.listener_mode == "on": |
| pass |
| else: |
| panic("Unhandled listener mode: %s" % options.listener_mode) |
| |
| if options.listener_loopback_only: |
| m5.listenersLoopbackOnly() |
| |
| # set debugging options |
| debug.setRemoteGDBPort(options.remote_gdb_port) |
| for when in options.debug_break: |
| debug.schedBreak(int(when)) |
| |
| if options.debug_flags: |
| _check_tracing() |
| |
| on_flags = [] |
| off_flags = [] |
| for flag in options.debug_flags: |
| off = False |
| if flag.startswith('-'): |
| flag = flag[1:] |
| off = True |
| |
| if flag not in debug.flags: |
| print("invalid debug flag '%s'" % flag, file=sys.stderr) |
| sys.exit(1) |
| |
| if off: |
| debug.flags[flag].disable() |
| else: |
| debug.flags[flag].enable() |
| |
| if options.debug_start: |
| _check_tracing() |
| e = event.create(trace.enable, event.Event.Debug_Enable_Pri) |
| event.mainq.schedule(e, options.debug_start) |
| else: |
| trace.enable() |
| |
| if options.debug_end: |
| _check_tracing() |
| e = event.create(trace.disable, event.Event.Debug_Enable_Pri) |
| event.mainq.schedule(e, options.debug_end) |
| |
| trace.output(options.debug_file) |
| |
| for ignore in options.debug_ignore: |
| _check_tracing() |
| trace.ignore(ignore) |
| |
| sys.argv = arguments |
| sys.path = [ os.path.dirname(sys.argv[0]) ] + sys.path |
| |
| filename = sys.argv[0] |
| filedata = open(filename, 'r').read() |
| filecode = compile(filedata, filename, 'exec') |
| scope = { '__file__' : filename, |
| '__name__' : '__m5_main__' } |
| |
| # if pdb was requested, execfile the thing under pdb, otherwise, |
| # just do the execfile normally |
| if options.pdb: |
| import pdb |
| import traceback |
| |
| pdb = pdb.Pdb() |
| try: |
| pdb.run(filecode, scope) |
| except SystemExit: |
| print("The program exited via sys.exit(). Exit status: ", end=' ') |
| print(sys.exc_info()[1]) |
| except: |
| traceback.print_exc() |
| print("Uncaught exception. Entering post mortem debugging") |
| t = sys.exc_info()[2] |
| while t.tb_next is not None: |
| t = t.tb_next |
| pdb.interaction(t.tb_frame,t) |
| else: |
| exec(filecode, scope) |
| |
| # once the script is done |
| if options.interactive: |
| interact(scope) |
| |
| if __name__ == '__main__': |
| from pprint import pprint |
| |
| options, arguments = parse_options() |
| |
| print('opts:') |
| pprint(options, indent=4) |
| print() |
| |
| print('args:') |
| pprint(arguments, indent=4) |
