From fcfc8b8c4ff98d69aa15fba60e723a9a1c4cda42 Mon Sep 17 00:00:00 2001 From: Rick Strong Date: Wed, 27 Feb 2008 00:35:09 -0500 Subject: Configs: Make using Simpoints easier with some config files that support them easily --HG-- extra : convert_revision : 0f21829306eb68b332f03da410e6c341c8595bdd --- configs/common/Simulation.py | 259 +++++++++++++++++++++++++++++-------------- 1 file changed, 175 insertions(+), 84 deletions(-) (limited to 'configs/common/Simulation.py') diff --git a/configs/common/Simulation.py b/configs/common/Simulation.py index f6b289fb5..9f3bf0cd9 100644 --- a/configs/common/Simulation.py +++ b/configs/common/Simulation.py @@ -51,7 +51,7 @@ def setCPUClass(options): test_mem_mode = 'atomic' if not atomic: - if options.checkpoint_restore: + if options.checkpoint_restore or options.fast_forward: CPUClass = TmpClass class TmpClass(AtomicSimpleCPU): pass else: @@ -86,6 +86,8 @@ def run(options, root, testsys, cpu_class): for i in xrange(np)] for i in xrange(np): + if options.fast_forward: + testsys.cpu[i].max_insts_any_thread = options.fast_forward switch_cpus[i].system = testsys if not m5.build_env['FULL_SYSTEM']: switch_cpus[i].workload = testsys.cpu[i].workload @@ -95,9 +97,6 @@ def run(options, root, testsys, cpu_class): switch_cpu_list = [(testsys.cpu[i], switch_cpus[i]) for i in xrange(np)] if options.standard_switch: - if (options.fast_forward and options.warmup): - m5.panic("Must specify either warmup OR fast-forward with -s!") - switch_cpus = [TimingSimpleCPU(defer_registration=True, cpu_id=(np+i)) for i in xrange(np)] switch_cpus_1 = [DerivO3CPU(defer_registration=True, cpu_id=(2*np+i)) @@ -112,8 +111,27 @@ def run(options, root, testsys, cpu_class): switch_cpus[i].clock = testsys.cpu[0].clock switch_cpus_1[i].clock = testsys.cpu[0].clock - if options.fast_forward: - switch_cpus[i].max_insts_any_thread = options.fast_forward + # if restoring, make atomic cpu simulate only a few instructions + if options.checkpoint_restore: + testsys.cpu[i].max_insts_any_thread = 1 + # Fast forward to specified location if we are not restoring + elif options.fast_forward: + testsys.cpu[i].max_insts_any_thread = options.fast_forward + # Fast forward to a simpoint (warning: time consuming) + elif options.simpoint: + if testsys.cpu[i].workload[0].simpoint == None: + m5.panic('simpoint not found') + testsys.cpu[i].max_insts_any_thread = \ + testsys.cpu[i].workload[0].simpoint + # No distance specified, just switch + else: + testsys.cpu[i].max_insts_any_thread = 1 + + # warmup period + if options.warmup_insts: + switch_cpus[i].max_insts_any_thread = options.warmup_insts + + # simulation period if options.max_inst: switch_cpus_1[i].max_insts_any_thread = options.max_inst @@ -123,136 +141,209 @@ def run(options, root, testsys, cpu_class): L1Cache(size = '64kB')) switch_cpus_1[i].connectMemPorts(testsys.membus) - 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)] - elif options.fast_forward: - for i in xrange(np): - testsys.cpu[i].max_insts_any_thread = options.fast_forward + # set the checkpoint in the cpu before m5.instantiate is called + if options.take_checkpoints and \ + (options.simpoint or options.at_instruction): + offset = int(options.take_checkpoints) + # Set an instruction break point + if options.simpoint: + for i in xrange(np): + if testsys.cpu[i].workload[0].simpoint == None: + m5.panic('no simpoint for testsys.cpu[%d].workload[0]' % i) + checkpoint_inst = testsys.cpu[i].workload[0].simpoint + offset + testsys.cpu[i].max_insts_any_thread = checkpoint_inst + # used for output below + options.take_checkpoints = checkpoint_inst + else: + options.take_checkpoints = offset + # Set all test cpus with the right number of instructions + # for the upcoming simulation + for i in xrange(np): + testsys.cpu[i].max_insts_any_thread = offset + + testsys.cpu_switch_list = cpu_switch_list m5.instantiate(root) if options.checkpoint_restore: - from os.path import isdir + from os.path import isdir, exists from os import listdir import re if not isdir(cptdir): m5.panic("checkpoint dir %s does not exist!" % cptdir) - dirs = listdir(cptdir) - expr = re.compile('cpt\.([0-9]*)') - cpts = [] - for dir in dirs: - match = expr.match(dir) - if match: - cpts.append(match.group(1)) + if options.at_instruction: + checkpoint_dir = joinpath(cptdir, "cpt.%s.%s" % \ + (options.bench, options.checkpoint_restore)) + if not exists(checkpoint_dir): + m5.panic("Unable to find checkpoint directory %s" % \ + checkpoint_dir) + + print "Restoring checkpoint ..." + m5.restoreCheckpoint(root, checkpoint_dir) + print "Done." + elif options.simpoint: + # assume workload 0 has the simpoint + if testsys.cpu[i].workload[0].simpoint == None: + m5.panic('Unable to find simpoint') + + options.checkpoint_restore += \ + testsys.cpu[0].workload[0].simpoint + + checkpoint_dir = joinpath(cptdir, "cpt.%s.%d" % \ + (options.bench, options.checkpoint_restore)) + if not exists(checkpoint_dir): + m5.panic("Unable to find checkpoint directory %s.%s" % \ + (options.bench, options.checkpoint_restore)) + + print "Restoring checkpoint ..." + m5.restoreCheckpoint(root,checkpoint_dir) + print "Done." + else: + dirs = listdir(cptdir) + expr = re.compile('cpt\.([0-9]*)') + cpts = [] + for dir in dirs: + match = expr.match(dir) + if match: + cpts.append(match.group(1)) - cpts.sort(lambda a,b: cmp(long(a), long(b))) + cpts.sort(lambda a,b: cmp(long(a), long(b))) - cpt_num = options.checkpoint_restore + cpt_num = options.checkpoint_restore - if cpt_num > len(cpts): - m5.panic('Checkpoint %d not found' % cpt_num) + if cpt_num > len(cpts): + m5.panic('Checkpoint %d not found' % cpt_num) - ## Adjust max tick based on our starting tick - maxtick = maxtick - int(cpts[cpt_num - 1]) + ## Adjust max tick based on our starting tick + maxtick = maxtick - int(cpts[cpt_num - 1]) - ## Restore the checkpoint - m5.restoreCheckpoint(root, - joinpath(cptdir, "cpt.%s" % cpts[cpt_num - 1])) + ## Restore the checkpoint + m5.restoreCheckpoint(root, + joinpath(cptdir, "cpt.%s" % cpts[cpt_num - 1])) if options.standard_switch or cpu_class: - exit_event = m5.simulate(10000) + if options.standard_switch: + 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) + exit_event = m5.simulate() + else: + print "Switch at curTick count:%s" % str(10000) + exit_event = m5.simulate(10000) + print "Switched CPUS @ cycle = %s" % (m5.curTick()) - ## when you change to Timing (or Atomic), you halt the system given - ## as argument. When you are finished with the system changes - ## (including switchCpus), you must resume the system manually. - ## You DON'T need to resume after just switching CPUs if you haven't - ## changed anything on the system level. + # when you change to Timing (or Atomic), you halt the system + # given as argument. When you are finished with the system + # changes (including switchCpus), you must resume the system + # manually. You DON'T need to resume after just switching + # CPUs if you haven't changed anything on the system level. m5.changeToTiming(testsys) m5.switchCpus(switch_cpu_list) m5.resume(testsys) if options.standard_switch: - if (options.warmup): - exit_event = m5.simulate(options.warmup) - if options.fast_forward: + 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.warmup) + print "Switching CPUS @ cycle = %s" % (m5.curTick()) + print "Simulation ends instruction count:%d" % \ + (testsys.switch_cpus_1[0].max_insts_any_thread) m5.drain(testsys) m5.switchCpus(switch_cpu_list1) m5.resume(testsys) - # This should *only* be used by itself to take a checkpoint! - # Otherwise, use standard_switch - elif options.fast_forward: - exit_event = m5.simulate() - - while exit_event.getCause() != "a thread reached the max instruction count": - if exit_event.getCause() == "user interrupt received": - print "User interrupt! Switching to simulation mode" - break - else: - m5.simulate(True) - - if exit_event.getCause() == "a thread reached the max instruction count": - print "Reached fast_forward count %d; starting simulation at cycle %d" % (options.fast_forward, m5.curTick()) - - m5.checkpoint(root, joinpath(cptdir, "cpt.%d")) - return - num_checkpoints = 0 exit_cause = '' - ## Checkpoints being taken via the command line at and at subsequent - ## periods of . Checkpoint instructions received from the benchmark running - ## are ignored and skipped in favor of command line checkpoint instructions. + # Checkpoints being taken via the command line at and at + # subsequent periods of . Checkpoint instructions + # received from the benchmark running are ignored and skipped in + # favor of command line checkpoint instructions. if options.take_checkpoints: - [when, period] = options.take_checkpoints.split(",", 1) + when, period = options.take_checkpoints.split(",", 1) when = int(when) period = int(period) - exit_event = m5.simulate(when) - while exit_event.getCause() == "checkpoint": - exit_event = m5.simulate(when - m5.curTick()) + if options.at_instruction or options.simpoint: + checkpoint_inst = when - if exit_event.getCause() == "simulate() limit reached": - m5.checkpoint(root, joinpath(cptdir, "cpt.%d")) - num_checkpoints += 1 + # maintain correct offset if we restored from some instruction + if options.checkpoint_restore: + checkpoint_inst += options.checkpoint_restore - sim_ticks = when - exit_cause = "maximum %d checkpoints dropped" % max_checkpoints - while num_checkpoints < max_checkpoints and \ - exit_event.getCause() == "simulate() limit reached": - if (sim_ticks + period) > maxtick: - exit_event = m5.simulate(maxtick - sim_ticks) - exit_cause = exit_event.getCause() - break - else: - exit_event = m5.simulate(period) - sim_ticks += period - while exit_event.getCause() == "checkpoint": - exit_event = m5.simulate(sim_ticks - m5.curTick()) - if exit_event.getCause() == "simulate() limit reached": - m5.checkpoint(root, joinpath(cptdir, "cpt.%d")) - num_checkpoints += 1 + print "Creating checkpoint at inst:%d" % (checkpoint_inst) + exit_event = m5.simulate() + print "exit cause = %s" % (exit_event.getCause()) - if exit_event.getCause() != "simulate() limit reached": - exit_cause = exit_event.getCause(); + # skip checkpoint instructions should they exist + while exit_event.getCause() == "checkpoint": + exit_event = m5.simulate() + if exit_event.getCause() == \ + "a thread reached the max instruction count": + m5.checkpoint(root, joinpath(cptdir, "cpt.%s.%d" % \ + (options.bench, checkpoint_inst))) + print "Checkpoint written." + num_checkpoints += 1 - else: #no checkpoints being taken via this script + if exit_event.getCause() == "user interrupt received": + exit_cause = exit_event.getCause(); + else: + exit_event = m5.simulate(when) + while exit_event.getCause() == "checkpoint": + exit_event = m5.simulate(when - m5.curTick()) + + if exit_event.getCause() == "simulate() limit reached": + m5.checkpoint(root, joinpath(cptdir, "cpt.%d")) + num_checkpoints += 1 + + sim_ticks = when + exit_cause = "maximum %d checkpoints dropped" % max_checkpoints + while num_checkpoints < max_checkpoints and \ + exit_event.getCause() == "simulate() limit reached": + if (sim_ticks + period) > maxtick: + exit_event = m5.simulate(maxtick - sim_ticks) + exit_cause = exit_event.getCause() + break + else: + exit_event = m5.simulate(period) + sim_ticks += period + while exit_event.getCause() == "checkpoint": + exit_event = m5.simulate(sim_ticks - m5.curTick()) + if exit_event.getCause() == "simulate() limit reached": + m5.checkpoint(root, joinpath(cptdir, "cpt.%d")) + num_checkpoints += 1 + + if exit_event.getCause() != "simulate() limit reached": + exit_cause = exit_event.getCause(); + + else: # no checkpoints being taken via this script + if options.fast_forward: + m5.stats.reset() + print "**** REAL SIMULATION ****" exit_event = m5.simulate(maxtick) while exit_event.getCause() == "checkpoint": m5.checkpoint(root, joinpath(cptdir, "cpt.%d")) num_checkpoints += 1 if num_checkpoints == max_checkpoints: - exit_cause = "maximum %d checkpoints dropped" % max_checkpoints + exit_cause = "maximum %d checkpoints dropped" % max_checkpoints break exit_event = m5.simulate(maxtick - m5.curTick()) -- cgit v1.2.3