Configs: Make using Simpoints easier with some config files that support them easily

--HG--
extra : convert_revision : 0f21829306eb68b332f03da410e6c341c8595bdd

1 files changed, 175 insertions, 84 deletions

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 <when> and at subsequent
-    ## periods of <period>.  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 <when> and at
+    # subsequent periods of <period>.  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())