#
# Authors: Ali Saidi
+from __future__ import print_function
+
from SysPaths import script, disk, binary
from os import environ as env
from m5.defines import buildEnv
elif buildEnv['TARGET_ISA'] == 'sparc':
return env.get('LINUX_IMAGE', disk('disk.s10hw2'))
else:
- print "Don't know what default disk image to use for %s ISA" % \
- buildEnv['TARGET_ISA']
+ print("Don't know what default disk image to use for %s ISA" %
+ buildEnv['TARGET_ISA'])
exit(1)
def rootdev(self):
# Configure the M5 cache hierarchy config in one place
#
+from __future__ import print_function
+
import m5
from m5.objects import *
from Caches import *
def config_cache(options, system):
if options.external_memory_system and (options.caches or options.l2cache):
- print "External caches and internal caches are exclusive options.\n"
+ print("External caches and internal caches are exclusive options.\n")
sys.exit(1)
if options.external_memory_system:
try:
from cores.arm.O3_ARM_v7a import *
except:
- print "O3_ARM_v7a_3 is unavailable. Did you compile the O3 model?"
+ print("O3_ARM_v7a_3 is unavailable. Did you compile the O3 model?")
sys.exit(1)
dcache_class, icache_class, l2_cache_class, walk_cache_class = \
#
# Authors: Andreas Sandberg
+from __future__ import print_function
+
from m5 import fatal
import m5.objects
import inspect
cpu_class = _cpu_classes[name]
return cpu_class
except KeyError:
- print "%s is not a valid CPU model." % (name,)
+ print("%s is not a valid CPU model." % (name,))
sys.exit(1)
def print_cpu_list():
"""Print a list of available CPU classes including their aliases."""
- print "Available CPU classes:"
+ print("Available CPU classes:")
doc_wrapper = TextWrapper(initial_indent="\t\t", subsequent_indent="\t\t")
for name, cls in _cpu_classes.items():
- print "\t%s" % name
+ print("\t%s" % name)
# Try to extract the class documentation from the class help
# string.
doc = inspect.getdoc(cls)
if doc:
for line in doc_wrapper.wrap(doc):
- print line
+ print(line)
def cpu_names():
"""Return a list of valid CPU names."""
#
# Authors: Kevin Lim
+from __future__ import print_function
+
from m5.objects import *
from Benchmarks import *
from m5.util import *
if isinstance(self.realview, VExpress_EMM64):
if os.path.split(mdesc.disk())[-1] == 'linux-aarch32-ael.img':
- print "Selected 64-bit ARM architecture, updating default disk image..."
+ print("Selected 64-bit ARM architecture, updating default "
+ "disk image...")
mdesc.diskname = 'linaro-minimal-aarch64.img'
# Author: Lisa Hsu
#
+from __future__ import print_function
+
# Configure the TLB hierarchy
# Places which would probably need to be modified if you
# want a different hierarchy are specified by a <Modify here .. >'
elif options.TLB_config == "2CU":
num_TLBs = n_cu >> 1
else:
- print "Bad option for TLB Configuration."
+ print("Bad option for TLB Configuration.")
sys.exit(1)
#----------------------------------------------------------------------------------------
# Authors: Andreas Sandberg
# Andreas Hansson
+from __future__ import print_function
+
import m5.objects
import inspect
import sys
mem_class = _mem_classes[name]
return mem_class
except KeyError:
- print "%s is not a valid memory controller." % (name,)
+ print("%s is not a valid memory controller." % (name,))
sys.exit(1)
def print_mem_list():
"""Print a list of available memory classes."""
- print "Available memory classes:"
+ print("Available memory classes:")
doc_wrapper = TextWrapper(initial_indent="\t\t", subsequent_indent="\t\t")
for name, cls in _mem_classes.items():
- print "\t%s" % name
+ print("\t%s" % name)
# Try to extract the class documentation from the class help
# string.
doc = inspect.getdoc(cls)
if doc:
for line in doc_wrapper.wrap(doc):
- print line
+ print(line)
def mem_names():
"""Return a list of valid memory names."""
if opt_elastic_trace_en:
mem_ctrl.latency = '1ns'
- print "For elastic trace, over-riding Simple Memory " \
- "latency to 1ns."
+ print("For elastic trace, over-riding Simple Memory "
+ "latency to 1ns.")
mem_ctrls.append(mem_ctrl)
# Authors: Andreas Sandberg
# Pierre-Yves Peneau
+from __future__ import print_function
+
import m5.objects
import inspect
import sys
def print_platform_list():
"""Print a list of available Platform classes including their aliases."""
- print "Available Platform classes:"
+ print("Available Platform classes:")
doc_wrapper = TextWrapper(initial_indent="\t\t", subsequent_indent="\t\t")
for name, cls in _platform_classes.items():
- print "\t%s" % name
+ print("\t%s" % name)
# Try to extract the class documentation from the class help
# string.
doc = inspect.getdoc(cls)
if doc:
for line in doc_wrapper.wrap(doc):
- print line
+ print(line)
if _platform_aliases:
- print "\Platform aliases:"
+ print("\Platform aliases:")
for alias, target in _platform_aliases.items():
- print "\t%s => %s" % (alias, target)
+ print("\t%s => %s" % (alias, target))
def platform_names():
"""Return a list of valid Platform names."""
#
# Authors: Lisa Hsu
+from __future__ import print_function
+
import sys
from os import getcwd
from os.path import join as joinpath
weight_inst = float(match.group(3))
interval_length = int(match.group(4))
warmup_length = int(match.group(5))
- print "Resuming from", checkpoint_dir
+ print("Resuming from", checkpoint_dir)
simpoint_start_insts = []
simpoint_start_insts.append(warmup_length)
simpoint_start_insts.append(warmup_length + interval_length)
if testsys.switch_cpus != None:
testsys.switch_cpus[0].simpoint_start_insts = simpoint_start_insts
- print "Resuming from SimPoint",
- print "#%d, start_inst:%d, weight:%f, interval:%d, warmup:%d" % \
- (index, start_inst, weight_inst, interval_length, warmup_length)
+ print("Resuming from SimPoint", end=' ')
+ print("#%d, start_inst:%d, weight:%f, interval:%d, warmup:%d" %
+ (index, start_inst, weight_inst, interval_length, warmup_length))
else:
dirs = listdir(cptdir)
if options.checkpoint_restore != None:
checkpoint_inst += options.checkpoint_restore
- print "Creating checkpoint at inst:%d" % (checkpoint_inst)
+ print("Creating checkpoint at inst:%d" % (checkpoint_inst))
exit_event = m5.simulate()
exit_cause = exit_event.getCause()
- print "exit cause = %s" % exit_cause
+ print("exit cause = %s" % exit_cause)
# skip checkpoint instructions should they exist
while exit_cause == "checkpoint":
if exit_cause == "a thread reached the max instruction count":
m5.checkpoint(joinpath(cptdir, "cpt.%s.%d" % \
(options.bench, checkpoint_inst)))
- print "Checkpoint written."
+ print("Checkpoint written.")
else:
when, period = options.take_checkpoints.split(",", 1)
simpoint_filename, weight_filename, interval_length, warmup_length = \
options.take_simpoint_checkpoints.split(",", 3)
- print "simpoint analysis file:", simpoint_filename
- print "simpoint weight file:", weight_filename
- print "interval length:", interval_length
- print "warmup length:", warmup_length
+ print("simpoint analysis file:", simpoint_filename)
+ print("simpoint weight file:", weight_filename)
+ print("interval length:", interval_length)
+ print("warmup length:", warmup_length)
interval_length = int(interval_length)
warmup_length = int(warmup_length)
simpoints.sort(key=lambda obj: obj[2])
for s in simpoints:
interval, weight, starting_inst_count, actual_warmup_length = s
- print str(interval), str(weight), starting_inst_count, \
- actual_warmup_length
+ print(str(interval), str(weight), starting_inst_count,
+ actual_warmup_length)
simpoint_start_insts.append(starting_inst_count)
- print "Total # of simpoints:", len(simpoints)
+ print("Total # of simpoints:", len(simpoints))
testsys.cpu[0].simpoint_start_insts = simpoint_start_insts
return (simpoints, interval_length)
# skip checkpoint instructions should they exist
while exit_event.getCause() == "checkpoint":
- print "Found 'checkpoint' exit event...ignoring..."
+ print("Found 'checkpoint' exit event...ignoring...")
exit_event = m5.simulate()
exit_cause = exit_event.getCause()
"cpt.simpoint_%02d_inst_%d_weight_%f_interval_%d_warmup_%d"
% (index, starting_inst_count, weight, interval_length,
actual_warmup_length)))
- print "Checkpoint #%d written. start inst:%d weight:%f" % \
- (num_checkpoints, starting_inst_count, weight)
+ print("Checkpoint #%d written. start inst:%d weight:%f" %
+ (num_checkpoints, starting_inst_count, weight))
num_checkpoints += 1
last_chkpnt_inst_count = starting_inst_count
else:
break
index += 1
- print 'Exiting @ tick %i because %s' % (m5.curTick(), exit_cause)
- print "%d checkpoints taken" % num_checkpoints
+ print('Exiting @ tick %i because %s' % (m5.curTick(), exit_cause))
+ print("%d checkpoints taken" % num_checkpoints)
sys.exit(code)
def restoreSimpointCheckpoint():
exit_cause = exit_event.getCause()
if exit_cause == "simpoint starting point found":
- print "Warmed up! Dumping and resetting stats!"
+ print("Warmed up! Dumping and resetting stats!")
m5.stats.dump()
m5.stats.reset()
exit_cause = exit_event.getCause()
if exit_cause == "simpoint starting point found":
- print "Done running SimPoint!"
+ print("Done running SimPoint!")
sys.exit(exit_event.getCode())
- print 'Exiting @ tick %i because %s' % (m5.curTick(), exit_cause)
+ print('Exiting @ tick %i because %s' % (m5.curTick(), exit_cause))
sys.exit(exit_event.getCode())
def repeatSwitch(testsys, repeat_switch_cpu_list, maxtick, switch_freq):
- print "starting switch loop"
+ print("starting switch loop")
while True:
exit_event = m5.simulate(switch_freq)
exit_cause = exit_event.getCause()
switch_class = getCPUClass(options.cpu_type)[0]
if switch_class.require_caches() and \
not options.caches:
- print "%s: Must be used with caches" % str(switch_class)
+ print("%s: Must be used with caches" % str(switch_class))
sys.exit(1)
if not switch_class.support_take_over():
- print "%s: CPU switching not supported" % str(switch_class)
+ print("%s: CPU switching not supported" % str(switch_class))
sys.exit(1)
repeat_switch_cpus = [switch_class(switched_out=True, \
if options.standard_switch or cpu_class:
if options.standard_switch:
- print "Switch at instruction count:%s" % \
- str(testsys.cpu[0].max_insts_any_thread)
+ print("Switch at instruction count:%s" %
+ str(testsys.cpu[0].max_insts_any_thread))
exit_event = m5.simulate()
elif cpu_class and options.fast_forward:
- print "Switch at instruction count:%s" % \
- str(testsys.cpu[0].max_insts_any_thread)
+ print("Switch at instruction count:%s" %
+ str(testsys.cpu[0].max_insts_any_thread))
exit_event = m5.simulate()
else:
- print "Switch at curTick count:%s" % str(10000)
+ print("Switch at curTick count:%s" % str(10000))
exit_event = m5.simulate(10000)
- print "Switched CPUS @ tick %s" % (m5.curTick())
+ print("Switched CPUS @ tick %s" % (m5.curTick()))
m5.switchCpus(testsys, switch_cpu_list)
if options.standard_switch:
- print "Switch at instruction count:%d" % \
- (testsys.switch_cpus[0].max_insts_any_thread)
+ print("Switch at instruction count:%d" %
+ (testsys.switch_cpus[0].max_insts_any_thread))
#warmup instruction count may have already been set
if options.warmup_insts:
exit_event = m5.simulate()
else:
exit_event = m5.simulate(options.standard_switch)
- print "Switching CPUS @ tick %s" % (m5.curTick())
- print "Simulation ends instruction count:%d" % \
- (testsys.switch_cpus_1[0].max_insts_any_thread)
+ print("Switching CPUS @ tick %s" % (m5.curTick()))
+ print("Simulation ends instruction count:%d" %
+ (testsys.switch_cpus_1[0].max_insts_any_thread))
m5.switchCpus(testsys, switch_cpu_list1)
# If we're taking and restoring checkpoints, use checkpoint_dir
else:
if options.fast_forward:
m5.stats.reset()
- print "**** REAL SIMULATION ****"
+ print("**** REAL SIMULATION ****")
# If checkpoints are being taken, then the checkpoint instruction
# will occur in the benchmark code it self.
else:
exit_event = benchCheckpoints(options, maxtick, cptdir)
- print 'Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause())
+ print('Exiting @ tick %i because %s' %
+ (m5.curTick(), exit_event.getCause()))
if options.checkpoint_at_end:
m5.checkpoint(joinpath(cptdir, "cpt.%d"))
"""
+from __future__ import print_function
+
from m5.objects import *
# Simple function to allow a string of [01x_] to be converted into a
elif char == 'x':
pass
else:
- print "Can't parse implicant character", char
+ print("Can't parse implicant character", char)
return (ret_mask, ret_match)
ret = TimingExprRef()
ret.index = env[name]
else:
- print "Invalid expression name", name
+ print("Invalid expression name", name)
ret = TimingExprNull()
return ret
return body
#
# Authors: Nathan Binkert
+from __future__ import print_function
+
import os
import sys
from os.path import basename, exists, join as joinpath, normpath
from pprint import pprint
for bench in all:
for input_set in 'ref', 'test', 'train':
- print 'class: %s' % bench.__name__
+ print('class: %s' % bench.__name__)
x = bench('alpha', 'tru64', input_set)
- print '%s: %s' % (x, input_set)
+ print('%s: %s' % (x, input_set))
pprint(x.makeProcessArgs())
- print
+ print()
#
# Authors: Andreas Hansson
+from __future__ import print_function
+
import gzip
import optparse
import os
try:
import packet_pb2
except:
- print "Did not find packet proto definitions, attempting to generate"
+ print("Did not find packet proto definitions, attempting to generate")
from subprocess import call
error = call(['protoc', '--python_out=configs/dram',
'--proto_path=src/proto', 'src/proto/packet.proto'])
if not error:
- print "Generated packet proto definitions"
+ print("Generated packet proto definitions")
try:
import google.protobuf
except:
- print "Please install the Python protobuf module"
+ print("Please install the Python protobuf module")
exit(-1)
import packet_pb2
else:
- print "Failed to import packet proto definitions"
+ print("Failed to import packet proto definitions")
exit(-1)
parser = optparse.OptionParser()
(options, args) = parser.parse_args()
if args:
- print "Error: script doesn't take any positional arguments"
+ print("Error: script doesn't take any positional arguments")
sys.exit(1)
# start by creating the system itself, using a multi-layer 2.0 GHz
try:
proto_out = gzip.open(filename, 'wb')
except IOError:
- print "Failed to open ", filename, " for writing"
+ print("Failed to open ", filename, " for writing")
exit(-1)
# write the magic number in 4-byte Little Endian, similar to what
proto_out.close()
# this will take a while, so keep the user informed
-print "Generating traces, please wait..."
+print("Generating traces, please wait...")
nxt_range = 0
nxt_state = 0
m5.simulate(nxt_state * period)
# print all we need to make sense of the stats output
-print "lat_mem_rd with %d iterations, ranges:" % iterations
+print("lat_mem_rd with %d iterations, ranges:" % iterations)
for r in ranges:
- print r
+ print(r)
# Authors: Radhika Jagtap
# Andreas Hansson
+from __future__ import print_function
+
import argparse
import m5
# Simulate for exactly as long as it takes to go through all the states
# This is why sim exists.
m5.simulate(nxt_state * period + idle_period)
-print "--- Done DRAM low power sweep ---"
-print "Fixed params - "
-print "\tburst: %d, banks: %d, max stride: %d, itt min: %s ns" % \
- (burst_size, nbr_banks, max_stride, itt_min)
-print "Swept params - "
-print "\titt max multiples input:", itt_max_multiples
-print "\titt max values", itt_max_values
-print "\tbank utilization values", bank_util_values
-print "\tstride values:", stride_values
-print "Traffic gen config file:", cfg_file_name
+print("--- Done DRAM low power sweep ---")
+print("Fixed params - ")
+print("\tburst: %d, banks: %d, max stride: %d, itt min: %s ns" % \
+ (burst_size, nbr_banks, max_stride, itt_min))
+print("Swept params - ")
+print("\titt max multiples input:", itt_max_multiples)
+print("\titt max values", itt_max_values)
+print("\tbank utilization values", bank_util_values)
+print("\tstride values:", stride_values)
+print("Traffic gen config file:", cfg_file_name)
#
# Authors: Andreas Hansson
+from __future__ import print_function
+
import optparse
import m5
(options, args) = parser.parse_args()
if args:
- print "Error: script doesn't take any positional arguments"
+ print("Error: script doesn't take any positional arguments")
sys.exit(1)
# at the moment we stay with the default open-adaptive page policy,
m5.instantiate()
m5.simulate(nxt_state * period)
-print "DRAM sweep with burst: %d, banks: %d, max stride: %d" % \
- (burst_size, nbr_banks, max_stride)
+print("DRAM sweep with burst: %d, banks: %d, max stride: %d" %
+ (burst_size, nbr_banks, max_stride))
# Author: Sooraj Puthoor
#
+from __future__ import print_function
+
import optparse, os, re
import math
import glob
kernel_path = os.path.dirname(executable)
kernel_files = glob.glob(os.path.join(kernel_path, '*.asm'))
if kernel_files:
- print "Using GPU kernel code file(s)", ",".join(kernel_files)
+ print("Using GPU kernel code file(s)", ",".join(kernel_files))
else:
fatal("Can't locate kernel code (.asm) in " + kernel_path)
for i in xrange(n_cu):
if i > 0 and not i % options.cu_per_sqc:
- print "incrementing idx on ", i
+ print("incrementing idx on ", i)
gpu_port_idx += 1
system.cpu[shader_idx].CUs[i].sqc_port = \
system.ruby._cpu_ports[gpu_port_idx].slave
host_cpu.workload[0].map(0x10000000, 0x200000000, 4096)
if options.fast_forward:
- print "Switch at instruction count: %d" % \
- cpu_list[0].max_insts_any_thread
+ print("Switch at instruction count: %d" % cpu_list[0].max_insts_any_thread)
exit_event = m5.simulate(maxtick)
if options.fast_forward:
if exit_event.getCause() == "a thread reached the max instruction count":
m5.switchCpus(system, switch_cpu_list)
- print "Switched CPUS @ tick %s" % (m5.curTick())
+ print("Switched CPUS @ tick %s" % (m5.curTick()))
m5.stats.reset()
exit_event = m5.simulate(maxtick - m5.curTick())
elif options.fast_forward_pseudo_op:
# If we are switching *to* kvm, then the current stats are meaningful
# Note that we don't do any warmup by default
if type(switch_cpu_list[0][0]) == FutureCpuClass:
- print "Dumping stats..."
+ print("Dumping stats...")
m5.stats.dump()
m5.switchCpus(system, switch_cpu_list)
- print "Switched CPUS @ tick %s" % (m5.curTick())
+ print("Switched CPUS @ tick %s" % (m5.curTick()))
m5.stats.reset()
# This lets us switch back and forth without keeping a counter
switch_cpu_list = [(x[1], x[0]) for x in switch_cpu_list]
exit_event = m5.simulate(maxtick - m5.curTick())
-print "Ticks:", m5.curTick()
-print 'Exiting because ', exit_event.getCause()
+print("Ticks:", m5.curTick())
+print('Exiting because ', exit_event.getCause())
sys.exit(exit_event.getCode())
# a generic ARM bigLITTLE system.
+from __future__ import print_function
+
import argparse
import os
import sys
event = m5.simulate()
exit_msg = event.getCause()
if exit_msg == "checkpoint":
- print "Dropping checkpoint at tick %d" % m5.curTick()
+ print("Dropping checkpoint at tick %d" % m5.curTick())
cpt_dir = os.path.join(checkpoint_dir, "cpt.%d" % m5.curTick())
m5.checkpoint(cpt_dir)
- print "Checkpoint done."
+ print("Checkpoint done.")
else:
- print exit_msg, " @ ", m5.curTick()
+ print(exit_msg, " @ ", m5.curTick())
break
sys.exit(event.getCode())
# This configuration file extends the example ARM big.LITTLE(tm)
# with example power models.
+from __future__ import print_function
+
import argparse
import os
bL.instantiate(options)
- print "*" * 70
- print "WARNING: The power numbers generated by this script are " \
- "examples. They are not representative of any particular " \
- "implementation or process."
- print "*" * 70
+ print("*" * 70)
+ print("WARNING: The power numbers generated by this script are "
+ "examples. They are not representative of any particular "
+ "implementation or process.")
+ print("*" * 70)
# Dumping stats periodically
m5.stats.periodicStatDump(m5.ticks.fromSeconds(0.1E-3))
at: http://www.arm.com/ResearchEnablement/SystemModeling
"""
+from __future__ import print_function
+
import os
import m5
from m5.util import addToPath
dtb_file = args.dtb
if args.script and not os.path.isfile(args.script):
- print "Error: Bootscript %s does not exist" % args.script
+ print("Error: Bootscript %s does not exist" % args.script)
sys.exit(1)
cpu_class = cpu_types[args.cpu][0]
def run(args):
cptdir = m5.options.outdir
if args.checkpoint:
- print "Checkpoint directory: %s" % cptdir
+ print("Checkpoint directory: %s" % cptdir)
while True:
event = m5.simulate()
exit_msg = event.getCause()
if exit_msg == "checkpoint":
- print "Dropping checkpoint at tick %d" % m5.curTick()
+ print("Dropping checkpoint at tick %d" % m5.curTick())
cpt_dir = os.path.join(m5.options.outdir, "cpt.%d" % m5.curTick())
m5.checkpoint(os.path.join(cpt_dir))
- print "Checkpoint done."
+ print("Checkpoint done.")
else:
- print exit_msg, " @ ", m5.curTick()
+ print(exit_msg, " @ ", m5.curTick())
break
sys.exit(event.getCode())
at: http://www.arm.com/ResearchEnablement/SystemModeling
"""
+from __future__ import print_function
+
import os
import m5
from m5.util import addToPath
process = Process(pid=100 + idx, cwd=cwd, cmd=argv, executable=argv[0])
- print "info: %d. command and arguments: %s" % (idx + 1, process.cmd)
+ print("info: %d. command and arguments: %s" % (idx + 1, process.cmd))
multiprocesses.append(process)
return multiprocesses
# that we can pass to gem5.
processes = get_processes(args.commands_to_run)
if len(processes) != args.num_cores:
- print "Error: Cannot map %d command(s) onto %d " \
- "CPU(s)" % (len(processes), args.num_cores)
+ print("Error: Cannot map %d command(s) onto %d CPU(s)" %
+ (len(processes), args.num_cores))
sys.exit(1)
# Assign one workload to each CPU
# Print the reason for the simulation exit. Some exit codes are
# requests for service (e.g., checkpoints) from the simulation
# script. We'll just ignore them here and exit.
- print event.getCause(), " @ ", m5.curTick()
+ print(event.getCause(), " @ ", m5.curTick())
sys.exit(event.getCode())
# Basic elastic traces replay script that configures a Trace CPU
+from __future__ import print_function
+
import optparse
from m5.util import addToPath, fatal
Options.addCommonOptions(parser)
if '--ruby' in sys.argv:
- print "This script does not support Ruby configuration, mainly"\
- " because Trace CPU has been tested only with classic memory system"
+ print("This script does not support Ruby configuration, mainly"
+ " because Trace CPU has been tested only with classic memory system")
sys.exit(1)
(options, args) = parser.parse_args()
if args:
- print "Error: script doesn't take any positional arguments"
+ print("Error: script doesn't take any positional arguments")
sys.exit(1)
numThreads = 1
# Authors: Ali Saidi
# Brad Beckmann
+from __future__ import print_function
+
import optparse
import sys
def cmd_line_template():
if options.command_line and options.command_line_file:
- print "Error: --command-line and --command-line-file are " \
- "mutually exclusive"
+ print("Error: --command-line and --command-line-file are "
+ "mutually exclusive")
sys.exit(1)
if options.command_line:
return options.command_line
(options, args) = parser.parse_args()
if args:
- print "Error: script doesn't take any positional arguments"
+ print("Error: script doesn't take any positional arguments")
sys.exit(1)
# system under test can be any CPU
try:
bm = Benchmarks[options.benchmark]
except KeyError:
- print "Error benchmark %s has not been defined." % options.benchmark
- print "Valid benchmarks are: %s" % DefinedBenchmarks
+ print("Error benchmark %s has not been defined." % options.benchmark)
+ print("Valid benchmarks are: %s" % DefinedBenchmarks)
sys.exit(1)
else:
if options.dual:
elif len(bm) == 1:
root = Root(full_system=True, system=test_sys)
else:
- print "Error I don't know how to create more than 2 systems."
+ print("Error I don't know how to create more than 2 systems.")
sys.exit(1)
if options.timesync:
#
# Author: Tushar Krishna
+from __future__ import print_function
+
import m5
from m5.objects import *
from m5.defines import buildEnv
(options, args) = parser.parse_args()
if args:
- print "Error: script doesn't take any positional arguments"
+ print("Error: script doesn't take any positional arguments")
sys.exit(1)
if options.inj_vnet > 2:
- print "Error: Injection vnet %d should be 0 (1-flit), 1 (1-flit) \
- or 2 (5-flit) or -1 (random)"\
- % (options.inj_vnet)
+ print("Error: Injection vnet %d should be 0 (1-flit), 1 (1-flit) "
+ "or 2 (5-flit) or -1 (random)" % (options.inj_vnet))
sys.exit(1)
# simulate until program terminates
exit_event = m5.simulate(options.abs_max_tick)
-print 'Exiting @ tick', m5.curTick(), 'because', exit_event.getCause()
+print('Exiting @ tick', m5.curTick(), 'because', exit_event.getCause())
+from __future__ import print_function
+
import sys
import argparse
import subprocess
root = build_system(options)
# instantiate all of the objects we've created so far
m5.instantiate()
- print "Beginning simulation!"
+ print("Beginning simulation!")
event = m5.simulate(10000000000)
m5.stats.dump()
- print 'Exiting @ tick %i because %s (exit code is %i)' % (m5.curTick(),
+ print('Exiting @ tick %i because %s (exit code is %i)' % (m5.curTick(),
event.getCause(),
- event.getCode())
- print "Done"
+ event.getCode()))
+ print("Done")
if __name__ == "__m5_main__":
# Authors: Ron Dreslinski
# Andreas Hansson
+from __future__ import print_function
+
import optparse
import random
import sys
(options, args) = parser.parse_args()
if args:
- print "Error: script doesn't take any positional arguments"
+ print("Error: script doesn't take any positional arguments")
sys.exit(1)
# Start by parsing the command line options and do some basic sanity
tree_depth = random.randint(1, 4)
cachespec = [random.randint(1, 3) for i in range(tree_depth)]
testerspec = [random.randint(1, 3) for i in range(tree_depth + 1)]
- print "Generated random tree -c", ':'.join(map(str, cachespec)), \
- "-t", ':'.join(map(str, testerspec))
+ print("Generated random tree -c", ':'.join(map(str, cachespec)),
+ "-t", ':'.join(map(str, testerspec)))
else:
try:
cachespec = [int(x) for x in options.caches.split(':')]
testerspec = [int(x) for x in options.testers.split(':')]
except:
- print "Error: Unable to parse caches or testers option"
+ print("Error: Unable to parse caches or testers option")
sys.exit(1)
if len(cachespec) < 1:
- print "Error: Must have at least one level of caches"
+ print("Error: Must have at least one level of caches")
sys.exit(1)
if len(cachespec) != len(testerspec) - 1:
- print "Error: Testers must have one element more than caches"
+ print("Error: Testers must have one element more than caches")
sys.exit(1)
if testerspec[-1] == 0:
- print "Error: Must have testers at the uppermost level"
+ print("Error: Must have testers at the uppermost level")
sys.exit(1)
for t in testerspec:
if t < 0:
- print "Error: Cannot have a negative number of testers"
+ print("Error: Cannot have a negative number of testers")
sys.exit(1)
for c in cachespec:
if c < 1:
- print "Error: Must have 1 or more caches at each level"
+ print("Error: Must have 1 or more caches at each level")
sys.exit(1)
# Determine the tester multiplier for each level as the string
multiplier = [1]
for c in cachespec:
if c < 1:
- print "Error: Must have at least one cache per level"
+ print("Error: Must have at least one cache per level")
multiplier.append(multiplier[-1] * c)
numtesters = 0
cache.mem_side = xbar.slave
else:
if not next_cache:
- print "Error: No next-level cache at top level"
+ print("Error: No next-level cache at top level")
sys.exit(1)
if ntesters > 1:
# Simulate until program terminates
exit_event = m5.simulate(options.maxtick)
-print 'Exiting @ tick', m5.curTick(), 'because', exit_event.getCause()
+print('Exiting @ tick', m5.curTick(), 'because', exit_event.getCause())
# Authors: Ron Dreslinski
# Andreas Hansson
+from __future__ import print_function
+
import optparse
import random
import sys
(options, args) = parser.parse_args()
if args:
- print "Error: script doesn't take any positional arguments"
+ print("Error: script doesn't take any positional arguments")
sys.exit(1)
# Get the total number of testers
if numtesters(cachespec, testerspec) < block_size:
break
- print "Generated random tree -c", ':'.join(map(str, cachespec)), \
- "-t", ':'.join(map(str, testerspec))
+ print("Generated random tree -c", ':'.join(map(str, cachespec)),
+ "-t", ':'.join(map(str, testerspec)))
else:
try:
cachespec = [int(x) for x in options.caches.split(':')]
testerspec = [int(x) for x in options.testers.split(':')]
except:
- print "Error: Unable to parse caches or testers option"
+ print("Error: Unable to parse caches or testers option")
sys.exit(1)
if len(cachespec) < 1:
- print "Error: Must have at least one level of caches"
+ print("Error: Must have at least one level of caches")
sys.exit(1)
if len(cachespec) != len(testerspec) - 1:
- print "Error: Testers must have one element more than caches"
+ print("Error: Testers must have one element more than caches")
sys.exit(1)
if testerspec[-1] == 0:
- print "Error: Must have testers at the uppermost level"
+ print("Error: Must have testers at the uppermost level")
sys.exit(1)
for t in testerspec:
if t < 0:
- print "Error: Cannot have a negative number of testers"
+ print("Error: Cannot have a negative number of testers")
sys.exit(1)
for c in cachespec:
if c < 1:
- print "Error: Must have 1 or more caches at each level"
+ print("Error: Must have 1 or more caches at each level")
sys.exit(1)
if numtesters(cachespec, testerspec) > block_size:
- print "Error: Limited to %s testers because of false sharing" \
- % (block_size)
+ print("Error: Limited to %s testers because of false sharing"
+ % (block_size))
sys.exit(1)
# Define a prototype L1 cache that we scale for all successive levels
cache.mem_side = xbar.slave
else:
if not next_cache:
- print "Error: No next-level cache at top level"
+ print("Error: No next-level cache at top level")
sys.exit(1)
if ntesters > 1:
# Simulate until program terminates
exit_event = m5.simulate(options.maxtick)
-print 'Exiting @ tick', m5.curTick(), 'because', exit_event.getCause()
+print('Exiting @ tick', m5.curTick(), 'because', exit_event.getCause())
# between system construction and run control may allow better
# debugging.
+from __future__ import print_function
+
import argparse
import ConfigParser
import inspect
m5.instantiate(args.checkpoint_dir)
exit_event = m5.simulate()
-print 'Exiting @ tick %i because %s' % (
- m5.curTick(), exit_event.getCause())
+print('Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause()))
# Authors: Ron Dreslinski
# Brad Beckmann
+from __future__ import print_function
+
import m5
from m5.objects import *
from m5.defines import buildEnv
(options, args) = parser.parse_args()
if args:
- print "Error: script doesn't take any positional arguments"
+ print("Error: script doesn't take any positional arguments")
sys.exit(1)
#
elif options.test_type == "Invalidate":
generator = InvalidateGenerator(num_cpus = options.num_cpus)
else:
- print "Error: unknown direct test generator"
+ print("Error: unknown direct test generator")
sys.exit(1)
# Create the M5 system.
# simulate until program terminates
exit_event = m5.simulate(options.abs_max_tick)
-print 'Exiting @ tick', m5.curTick(), 'because', exit_event.getCause()
+print('Exiting @ tick', m5.curTick(), 'because', exit_event.getCause())
# Author: Brad Beckmann
#
+from __future__ import print_function
+
import m5
from m5.objects import *
from m5.defines import buildEnv
options.num_sqc = int((n_cu + options.cu_per_sqc - 1) / options.cu_per_sqc)
if args:
- print "Error: script doesn't take any positional arguments"
+ print("Error: script doesn't take any positional arguments")
sys.exit(1)
#
# simulate until program terminates
exit_event = m5.simulate(options.abs_max_tick)
-print 'Exiting @ tick', m5.curTick(), 'because', exit_event.getCause()
+print('Exiting @ tick', m5.curTick(), 'because', exit_event.getCause())
# Authors: Ron Dreslinski
# Brad Beckmann
+from __future__ import print_function
+
import m5
from m5.objects import *
from m5.defines import buildEnv
options.l3_assoc=2
if args:
- print "Error: script doesn't take any positional arguments"
+ print("Error: script doesn't take any positional arguments")
sys.exit(1)
block_size = 64
if options.num_cpus > block_size:
- print "Error: Number of testers %d limited to %d because of false sharing" \
- % (options.num_cpus, block_size)
+ print("Error: Number of testers %d limited to %d because of false sharing"
+ % (options.num_cpus, block_size))
sys.exit(1)
#
# simulate until program terminates
exit_event = m5.simulate(options.abs_max_tick)
-print 'Exiting @ tick', m5.curTick(), 'because', exit_event.getCause()
+print('Exiting @ tick', m5.curTick(), 'because', exit_event.getCause())
# Authors: Ron Dreslinski
# Brad Beckmann
+from __future__ import print_function
+
import m5
from m5.objects import *
from m5.defines import buildEnv
options.l3_assoc=2
if args:
- print "Error: script doesn't take any positional arguments"
+ print("Error: script doesn't take any positional arguments")
sys.exit(1)
#
# simulate until program terminates
exit_event = m5.simulate(options.abs_max_tick)
-print 'Exiting @ tick', m5.curTick(), 'because', exit_event.getCause()
+print('Exiting @ tick', m5.curTick(), 'because', exit_event.getCause())
#
# "m5 test.py"
+from __future__ import print_function
+
import optparse
import sys
import os
(options, args) = parser.parse_args()
if args:
- print "Error: script doesn't take any positional arguments"
+ print("Error: script doesn't take any positional arguments")
sys.exit(1)
multiprocesses = []
if options.bench:
apps = options.bench.split("-")
if len(apps) != options.num_cpus:
- print "number of benchmarks not equal to set num_cpus!"
+ print("number of benchmarks not equal to set num_cpus!")
sys.exit(1)
for app in apps:
app, options.spec_input))
multiprocesses.append(workload.makeProcess())
except:
- print >>sys.stderr, "Unable to find workload for %s: %s" % (
- buildEnv['TARGET_ISA'], app)
+ print("Unable to find workload for %s: %s" %
+ (buildEnv['TARGET_ISA'], app),
+ file=sys.stderr)
sys.exit(1)
elif options.cmd:
multiprocesses, numThreads = get_processes(options)
else:
- print >> sys.stderr, "No workload specified. Exiting!\n"
+ print("No workload specified. Exiting!\n", file=sys.stderr)
sys.exit(1)
"""
+from __future__ import print_function
+
# import the m5 (gem5) library created when gem5 is built
import m5
# import all of the SimObjects
# instantiate all of the objects we've created above
m5.instantiate()
-print "Beginning simulation!"
+print("Beginning simulation!")
exit_event = m5.simulate()
-print 'Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause())
+print('Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause()))
"""
+from __future__ import print_function
+
# import the m5 (gem5) library created when gem5 is built
import m5
# import all of the SimObjects
# instantiate all of the objects we've created above
m5.instantiate()
-print "Beginning simulation!"
+print("Beginning simulation!")
exit_event = m5.simulate()
-print 'Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause())
+print('Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause()))
"""
+from __future__ import print_function
+
# import the m5 (gem5) library created when gem5 is built
import m5
# import all of the SimObjects
# instantiate all of the objects we've created above
m5.instantiate()
-print "Beginning simulation!"
+print("Beginning simulation!")
exit_event = m5.simulate()
-print 'Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause())
+print('Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause()))
"""
+from __future__ import print_function
+
# import the m5 (gem5) library created when gem5 is built
import m5
# import all of the SimObjects
# instantiate all of the objects we've created above
m5.instantiate()
-print "Beginning simulation!"
+print("Beginning simulation!")
exit_event = m5.simulate()
-print 'Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause())
+print('Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause()))
This config file assumes that the x86 ISA was built.
"""
+from __future__ import print_function
+
# import the m5 (gem5) library created when gem5 is built
import m5
# import all of the SimObjects
# instantiate all of the objects we've created above
m5.instantiate()
-print "Beginning simulation!"
+print("Beginning simulation!")
exit_event = m5.simulate()
-print 'Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause())
+print('Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause()))
This config file assumes that the x86 ISA was built.
"""
+from __future__ import print_function
+
# import the m5 (gem5) library created when gem5 is built
import m5
# import all of the SimObjects
# instantiate all of the objects we've created above
m5.instantiate()
-print "Beginning simulation!"
+print("Beginning simulation!")
exit_event = m5.simulate()
-print 'Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause())
+print('Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause()))
#
# Authors: Brad Beckmann
+from __future__ import print_function
+
import math
import m5
from m5.objects import *
ruby)"
% protocol)
except:
- print "Error: could not create sytem for ruby protocol %s" % protocol
+ print("Error: could not create sytem for ruby protocol %s" % protocol)
raise
# Create the network topology
#
# "m5 test.py"
+from __future__ import print_function
+
import os
import optparse
import sys
(options, args) = parser.parse_args()
if args:
- print "Error: script doesn't take any positional arguments"
+ print("Error: script doesn't take any positional arguments")
sys.exit(1)
# --------------------
else:
exit_event = m5.simulate(m5.MaxTick)
-print 'Exiting @ tick', m5.curTick(), 'because', exit_event.getCause()
+print('Exiting @ tick', m5.curTick(), 'because', exit_event.getCause())
# Splash2 Run Script
#
+from __future__ import print_function
+
import os
import optparse
import sys
(options, args) = parser.parse_args()
if args:
- print "Error: script doesn't take any positional arguments"
+ print("Error: script doesn't take any positional arguments")
sys.exit(1)
if not options.numcpus:
- print "Specify the number of cpus with -n"
+ print("Specify the number of cpus with -n")
sys.exit(1)
# --------------------
elif options.benchmark == 'WaterSpatial':
root.workload = Water_spatial()
else:
- print >> sys.stderr, """The --benchmark environment variable was set to something improper.
-Use Cholesky, FFT, LUContig, LUNoncontig, Radix, Barnes, FMM, OceanContig,
-OceanNoncontig, Raytrace, WaterNSquared, or WaterSpatial"""
+ print("The --benchmark environment variable was set to something "
+ "improper. Use Cholesky, FFT, LUContig, LUNoncontig, Radix, "
+ "Barnes, FMM, OceanContig, OceanNoncontig, Raytrace, WaterNSquared, "
+ "or WaterSpatial", file=sys.stderr)
sys.exit(1)
# --------------------
else:
exit_event = m5.simulate(m5.MaxTick)
-print 'Exiting @ tick', m5.curTick(), 'because', exit_event.getCause()
+print('Exiting @ tick', m5.curTick(), 'because', exit_event.getCause())
projects / gem5.git / commitdiff