# 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: Lisa Hsu
+from __future__ import print_function
+from __future__ import absolute_import
+
+import six
import sys
from os import getcwd
from os.path import join as joinpath
from common import CpuConfig
-from common import MemConfig
+from common import ObjectList
import m5
from m5.defines import buildEnv
from m5.objects import *
from m5.util import *
+if six.PY3:
+ long = int
+
addToPath('../common')
def getCPUClass(cpu_type):
"""Returns the required cpu class and the mode of operation."""
- cls = CpuConfig.get(cpu_type)
+ cls = ObjectList.cpu_list.get(cpu_type)
return cls, cls.memory_mode()
def setCPUClass(options):
TmpClass = AtomicSimpleCPU
test_mem_mode = 'atomic'
+ # Ruby only supports atomic accesses in noncaching mode
+ if test_mem_mode == 'atomic' and options.ruby:
+ warn("Memory mode will be changed to atomic_noncaching")
+ test_mem_mode = 'atomic_noncaching'
+
return (TmpClass, test_mem_mode, CPUClass)
def setMemClass(options):
"""Returns a memory controller class."""
- return MemConfig.get(options.mem_type)
+ return ObjectList.mem_list.get(options.mem_type)
def setWorkCountOptions(system, options):
if options.work_item_id != None:
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_cpus = None
if options.prog_interval:
- for i in xrange(np):
+ for i in range(np):
testsys.cpu[i].progress_interval = options.prog_interval
if options.maxinsts:
- for i in xrange(np):
+ for i in range(np):
testsys.cpu[i].max_insts_any_thread = options.maxinsts
if cpu_class:
switch_cpus = [cpu_class(switched_out=True, cpu_id=(i))
- for i in xrange(np)]
+ for i in range(np)]
- for i in xrange(np):
+ for i in range(np):
if options.fast_forward:
testsys.cpu[i].max_insts_any_thread = int(options.fast_forward)
switch_cpus[i].system = testsys
# Add checker cpu if selected
if options.checker:
switch_cpus[i].addCheckerCpu()
+ if options.bp_type:
+ bpClass = ObjectList.bp_list.get(options.bp_type)
+ switch_cpus[i].branchPred = bpClass()
+ if options.indirect_bp_type:
+ IndirectBPClass = ObjectList.indirect_bp_list.get(
+ options.indirect_bp_type)
+ switch_cpus[i].branchPred.indirectBranchPred = \
+ IndirectBPClass()
# If elastic tracing is enabled attach the elastic trace probe
# to the switch CPUs
CpuConfig.config_etrace(cpu_class, switch_cpus, options)
testsys.switch_cpus = switch_cpus
- switch_cpu_list = [(testsys.cpu[i], switch_cpus[i]) for i in xrange(np)]
+ switch_cpu_list = [(testsys.cpu[i], switch_cpus[i]) for i in range(np)]
if options.repeat_switch:
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, \
- cpu_id=(i)) for i in xrange(np)]
+ cpu_id=(i)) for i in range(np)]
- for i in xrange(np):
+ for i in range(np):
repeat_switch_cpus[i].system = testsys
repeat_switch_cpus[i].workload = testsys.cpu[i].workload
repeat_switch_cpus[i].clk_domain = testsys.cpu[i].clk_domain
if cpu_class:
repeat_switch_cpu_list = [(switch_cpus[i], repeat_switch_cpus[i])
- for i in xrange(np)]
+ for i in range(np)]
else:
repeat_switch_cpu_list = [(testsys.cpu[i], repeat_switch_cpus[i])
- for i in xrange(np)]
+ for i in range(np)]
if options.standard_switch:
switch_cpus = [TimingSimpleCPU(switched_out=True, cpu_id=(i))
- for i in xrange(np)]
+ for i in range(np)]
switch_cpus_1 = [DerivO3CPU(switched_out=True, cpu_id=(i))
- for i in xrange(np)]
+ for i in range(np)]
- for i in xrange(np):
+ for i in range(np):
switch_cpus[i].system = testsys
switch_cpus_1[i].system = testsys
switch_cpus[i].workload = testsys.cpu[i].workload
testsys.switch_cpus = switch_cpus
testsys.switch_cpus_1 = switch_cpus_1
- switch_cpu_list = [(testsys.cpu[i], switch_cpus[i]) for i in xrange(np)]
- switch_cpu_list1 = [(switch_cpus[i], switch_cpus_1[i]) for i in xrange(np)]
+ switch_cpu_list = [
+ (testsys.cpu[i], switch_cpus[i]) for i in range(np)
+ ]
+ switch_cpu_list1 = [
+ (switch_cpus[i], switch_cpus_1[i]) for i in range(np)
+ ]
# set the checkpoint in the cpu before m5.instantiate is called
if options.take_checkpoints != None and \
offset = int(options.take_checkpoints)
# Set an instruction break point
if options.simpoint:
- for i in xrange(np):
+ for i in range(np):
if testsys.cpu[i].workload[0].simpoint == 0:
fatal('no simpoint for testsys.cpu[%d].workload[0]', i)
checkpoint_inst = int(testsys.cpu[i].workload[0].simpoint) + offset
options.take_checkpoints = offset
# Set all test cpus with the right number of instructions
# for the upcoming simulation
- for i in xrange(np):
+ for i in range(np):
testsys.cpu[i].max_insts_any_thread = offset
if options.take_simpoint_checkpoints != None:
checkpoint_dir = None
if options.checkpoint_restore:
cpt_starttick, checkpoint_dir = findCptDir(options, cptdir, testsys)
+ root.apply_config(options.param)
m5.instantiate(checkpoint_dir)
# Initialization is complete. If we're not in control of simulation
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"))
- if not m5.options.interactive:
- sys.exit(exit_event.getCode())
+ if exit_event.getCode() != 0:
+ print("Simulated exit code not 0! Exit code is", exit_event.getCode())