Simulation.py revision 10757:8a4040874157
1# Copyright (c) 2012-2013 ARM Limited 2# All rights reserved 3# 4# The license below extends only to copyright in the software and shall 5# not be construed as granting a license to any other intellectual 6# property including but not limited to intellectual property relating 7# to a hardware implementation of the functionality of the software 8# licensed hereunder. You may use the software subject to the license 9# terms below provided that you ensure that this notice is replicated 10# unmodified and in its entirety in all distributions of the software, 11# modified or unmodified, in source code or in binary form. 12# 13# Copyright (c) 2006-2008 The Regents of The University of Michigan 14# Copyright (c) 2010 Advanced Micro Devices, Inc. 15# All rights reserved. 16# 17# Redistribution and use in source and binary forms, with or without 18# modification, are permitted provided that the following conditions are 19# met: redistributions of source code must retain the above copyright 20# notice, this list of conditions and the following disclaimer; 21# redistributions in binary form must reproduce the above copyright 22# notice, this list of conditions and the following disclaimer in the 23# documentation and/or other materials provided with the distribution; 24# neither the name of the copyright holders nor the names of its 25# contributors may be used to endorse or promote products derived from 26# this software without specific prior written permission. 27# 28# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 29# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 30# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 31# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 32# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 33# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 34# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 35# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 36# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 37# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 38# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 39# 40# Authors: Lisa Hsu 41 42import sys 43from os import getcwd 44from os.path import join as joinpath 45 46import CpuConfig 47import MemConfig 48 49import m5 50from m5.defines import buildEnv 51from m5.objects import * 52from m5.util import * 53 54addToPath('../common') 55 56def getCPUClass(cpu_type): 57 """Returns the required cpu class and the mode of operation.""" 58 cls = CpuConfig.get(cpu_type) 59 return cls, cls.memory_mode() 60 61def setCPUClass(options): 62 """Returns two cpu classes and the initial mode of operation. 63 64 Restoring from a checkpoint or fast forwarding through a benchmark 65 can be done using one type of cpu, and then the actual 66 simulation can be carried out using another type. This function 67 returns these two types of cpus and the initial mode of operation 68 depending on the options provided. 69 """ 70 71 TmpClass, test_mem_mode = getCPUClass(options.cpu_type) 72 CPUClass = None 73 if TmpClass.require_caches() and \ 74 not options.caches and not options.ruby: 75 fatal("%s must be used with caches" % options.cpu_type) 76 77 if options.checkpoint_restore != None: 78 if options.restore_with_cpu != options.cpu_type: 79 CPUClass = TmpClass 80 TmpClass, test_mem_mode = getCPUClass(options.restore_with_cpu) 81 elif options.fast_forward: 82 CPUClass = TmpClass 83 TmpClass = AtomicSimpleCPU 84 test_mem_mode = 'atomic' 85 86 return (TmpClass, test_mem_mode, CPUClass) 87 88def setMemClass(options): 89 """Returns a memory controller class.""" 90 91 return MemConfig.get(options.mem_type) 92 93def setWorkCountOptions(system, options): 94 if options.work_item_id != None: 95 system.work_item_id = options.work_item_id 96 if options.num_work_ids != None: 97 system.num_work_ids = options.num_work_ids 98 if options.work_begin_cpu_id_exit != None: 99 system.work_begin_cpu_id_exit = options.work_begin_cpu_id_exit 100 if options.work_end_exit_count != None: 101 system.work_end_exit_count = options.work_end_exit_count 102 if options.work_end_checkpoint_count != None: 103 system.work_end_ckpt_count = options.work_end_checkpoint_count 104 if options.work_begin_exit_count != None: 105 system.work_begin_exit_count = options.work_begin_exit_count 106 if options.work_begin_checkpoint_count != None: 107 system.work_begin_ckpt_count = options.work_begin_checkpoint_count 108 if options.work_cpus_checkpoint_count != None: 109 system.work_cpus_ckpt_count = options.work_cpus_checkpoint_count 110 111def findCptDir(options, cptdir, testsys): 112 """Figures out the directory from which the checkpointed state is read. 113 114 There are two different ways in which the directories holding checkpoints 115 can be named -- 116 1. cpt.<benchmark name>.<instruction count when the checkpoint was taken> 117 2. cpt.<some number, usually the tick value when the checkpoint was taken> 118 119 This function parses through the options to figure out which one of the 120 above should be used for selecting the checkpoint, and then figures out 121 the appropriate directory. 122 """ 123 124 from os.path import isdir, exists 125 from os import listdir 126 import re 127 128 if not isdir(cptdir): 129 fatal("checkpoint dir %s does not exist!", cptdir) 130 131 cpt_starttick = 0 132 if options.at_instruction or options.simpoint: 133 inst = options.checkpoint_restore 134 if options.simpoint: 135 # assume workload 0 has the simpoint 136 if testsys.cpu[0].workload[0].simpoint == 0: 137 fatal('Unable to find simpoint') 138 inst += int(testsys.cpu[0].workload[0].simpoint) 139 140 checkpoint_dir = joinpath(cptdir, "cpt.%s.%s" % (options.bench, inst)) 141 if not exists(checkpoint_dir): 142 fatal("Unable to find checkpoint directory %s", checkpoint_dir) 143 144 elif options.restore_simpoint_checkpoint: 145 # Restore from SimPoint checkpoints 146 # Assumes that the checkpoint dir names are formatted as follows: 147 dirs = listdir(cptdir) 148 expr = re.compile('cpt\.simpoint_(\d+)_inst_(\d+)' + 149 '_weight_([\d\.e\-]+)_interval_(\d+)_warmup_(\d+)') 150 cpts = [] 151 for dir in dirs: 152 match = expr.match(dir) 153 if match: 154 cpts.append(dir) 155 cpts.sort() 156 157 cpt_num = options.checkpoint_restore 158 if cpt_num > len(cpts): 159 fatal('Checkpoint %d not found', cpt_num) 160 checkpoint_dir = joinpath(cptdir, cpts[cpt_num - 1]) 161 match = expr.match(cpts[cpt_num - 1]) 162 if match: 163 index = int(match.group(1)) 164 start_inst = int(match.group(2)) 165 weight_inst = float(match.group(3)) 166 interval_length = int(match.group(4)) 167 warmup_length = int(match.group(5)) 168 print "Resuming from", checkpoint_dir 169 simpoint_start_insts = [] 170 simpoint_start_insts.append(warmup_length) 171 simpoint_start_insts.append(warmup_length + interval_length) 172 testsys.cpu[0].simpoint_start_insts = simpoint_start_insts 173 if testsys.switch_cpus != None: 174 testsys.switch_cpus[0].simpoint_start_insts = simpoint_start_insts 175 176 print "Resuming from SimPoint", 177 print "#%d, start_inst:%d, weight:%f, interval:%d, warmup:%d" % \ 178 (index, start_inst, weight_inst, interval_length, warmup_length) 179 180 else: 181 dirs = listdir(cptdir) 182 expr = re.compile('cpt\.([0-9]+)') 183 cpts = [] 184 for dir in dirs: 185 match = expr.match(dir) 186 if match: 187 cpts.append(match.group(1)) 188 189 cpts.sort(lambda a,b: cmp(long(a), long(b))) 190 191 cpt_num = options.checkpoint_restore 192 if cpt_num > len(cpts): 193 fatal('Checkpoint %d not found', cpt_num) 194 195 cpt_starttick = int(cpts[cpt_num - 1]) 196 checkpoint_dir = joinpath(cptdir, "cpt.%s" % cpts[cpt_num - 1]) 197 198 return cpt_starttick, checkpoint_dir 199 200def scriptCheckpoints(options, maxtick, cptdir): 201 if options.at_instruction or options.simpoint: 202 checkpoint_inst = int(options.take_checkpoints) 203 204 # maintain correct offset if we restored from some instruction 205 if options.checkpoint_restore != None: 206 checkpoint_inst += options.checkpoint_restore 207 208 print "Creating checkpoint at inst:%d" % (checkpoint_inst) 209 exit_event = m5.simulate() 210 exit_cause = exit_event.getCause() 211 print "exit cause = %s" % exit_cause 212 213 # skip checkpoint instructions should they exist 214 while exit_cause == "checkpoint": 215 exit_event = m5.simulate() 216 exit_cause = exit_event.getCause() 217 218 if exit_cause == "a thread reached the max instruction count": 219 m5.checkpoint(joinpath(cptdir, "cpt.%s.%d" % \ 220 (options.bench, checkpoint_inst))) 221 print "Checkpoint written." 222 223 else: 224 when, period = options.take_checkpoints.split(",", 1) 225 when = int(when) 226 period = int(period) 227 num_checkpoints = 0 228 229 exit_event = m5.simulate(when - m5.curTick()) 230 exit_cause = exit_event.getCause() 231 while exit_cause == "checkpoint": 232 exit_event = m5.simulate(when - m5.curTick()) 233 exit_cause = exit_event.getCause() 234 235 if exit_cause == "simulate() limit reached": 236 m5.checkpoint(joinpath(cptdir, "cpt.%d")) 237 num_checkpoints += 1 238 239 sim_ticks = when 240 max_checkpoints = options.max_checkpoints 241 242 while num_checkpoints < max_checkpoints and \ 243 exit_cause == "simulate() limit reached": 244 if (sim_ticks + period) > maxtick: 245 exit_event = m5.simulate(maxtick - sim_ticks) 246 exit_cause = exit_event.getCause() 247 break 248 else: 249 exit_event = m5.simulate(period) 250 exit_cause = exit_event.getCause() 251 sim_ticks += period 252 while exit_event.getCause() == "checkpoint": 253 exit_event = m5.simulate(sim_ticks - m5.curTick()) 254 if exit_event.getCause() == "simulate() limit reached": 255 m5.checkpoint(joinpath(cptdir, "cpt.%d")) 256 num_checkpoints += 1 257 258 return exit_event 259 260def benchCheckpoints(options, maxtick, cptdir): 261 exit_event = m5.simulate(maxtick - m5.curTick()) 262 exit_cause = exit_event.getCause() 263 264 num_checkpoints = 0 265 max_checkpoints = options.max_checkpoints 266 267 while exit_cause == "checkpoint": 268 m5.checkpoint(joinpath(cptdir, "cpt.%d")) 269 num_checkpoints += 1 270 if num_checkpoints == max_checkpoints: 271 exit_cause = "maximum %d checkpoints dropped" % max_checkpoints 272 break 273 274 exit_event = m5.simulate(maxtick - m5.curTick()) 275 exit_cause = exit_event.getCause() 276 277 return exit_event 278 279# Set up environment for taking SimPoint checkpoints 280# Expecting SimPoint files generated by SimPoint 3.2 281def parseSimpointAnalysisFile(options, testsys): 282 import re 283 284 simpoint_filename, weight_filename, interval_length, warmup_length = \ 285 options.take_simpoint_checkpoints.split(",", 3) 286 print "simpoint analysis file:", simpoint_filename 287 print "simpoint weight file:", weight_filename 288 print "interval length:", interval_length 289 print "warmup length:", warmup_length 290 291 interval_length = int(interval_length) 292 warmup_length = int(warmup_length) 293 294 # Simpoint analysis output starts interval counts with 0. 295 simpoints = [] 296 simpoint_start_insts = [] 297 298 # Read in SimPoint analysis files 299 simpoint_file = open(simpoint_filename) 300 weight_file = open(weight_filename) 301 while True: 302 line = simpoint_file.readline() 303 if not line: 304 break 305 m = re.match("(\d+)\s+(\d+)", line) 306 if m: 307 interval = int(m.group(1)) 308 else: 309 fatal('unrecognized line in simpoint file!') 310 311 line = weight_file.readline() 312 if not line: 313 fatal('not enough lines in simpoint weight file!') 314 m = re.match("([0-9\.e\-]+)\s+(\d+)", line) 315 if m: 316 weight = float(m.group(1)) 317 else: 318 fatal('unrecognized line in simpoint weight file!') 319 320 if (interval * interval_length - warmup_length > 0): 321 starting_inst_count = \ 322 interval * interval_length - warmup_length 323 actual_warmup_length = warmup_length 324 else: 325 # Not enough room for proper warmup 326 # Just starting from the beginning 327 starting_inst_count = 0 328 actual_warmup_length = interval * interval_length 329 330 simpoints.append((interval, weight, starting_inst_count, 331 actual_warmup_length)) 332 333 # Sort SimPoints by starting inst count 334 simpoints.sort(key=lambda obj: obj[2]) 335 for s in simpoints: 336 interval, weight, starting_inst_count, actual_warmup_length = s 337 print str(interval), str(weight), starting_inst_count, \ 338 actual_warmup_length 339 simpoint_start_insts.append(starting_inst_count) 340 341 print "Total # of simpoints:", len(simpoints) 342 testsys.cpu[0].simpoint_start_insts = simpoint_start_insts 343 344 return (simpoints, interval_length) 345 346def takeSimpointCheckpoints(simpoints, interval_length, cptdir): 347 num_checkpoints = 0 348 index = 0 349 last_chkpnt_inst_count = -1 350 for simpoint in simpoints: 351 interval, weight, starting_inst_count, actual_warmup_length = simpoint 352 if starting_inst_count == last_chkpnt_inst_count: 353 # checkpoint starting point same as last time 354 # (when warmup period longer than starting point) 355 exit_cause = "simpoint starting point found" 356 code = 0 357 else: 358 exit_event = m5.simulate() 359 360 # skip checkpoint instructions should they exist 361 while exit_event.getCause() == "checkpoint": 362 print "Found 'checkpoint' exit event...ignoring..." 363 exit_event = m5.simulate() 364 365 exit_cause = exit_event.getCause() 366 code = exit_event.getCode() 367 368 if exit_cause == "simpoint starting point found": 369 m5.checkpoint(joinpath(cptdir, 370 "cpt.simpoint_%02d_inst_%d_weight_%f_interval_%d_warmup_%d" 371 % (index, starting_inst_count, weight, interval_length, 372 actual_warmup_length))) 373 print "Checkpoint #%d written. start inst:%d weight:%f" % \ 374 (num_checkpoints, starting_inst_count, weight) 375 num_checkpoints += 1 376 last_chkpnt_inst_count = starting_inst_count 377 else: 378 break 379 index += 1 380 381 print 'Exiting @ tick %i because %s' % (m5.curTick(), exit_cause) 382 print "%d checkpoints taken" % num_checkpoints 383 sys.exit(code) 384 385def restoreSimpointCheckpoint(): 386 exit_event = m5.simulate() 387 exit_cause = exit_event.getCause() 388 389 if exit_cause == "simpoint starting point found": 390 print "Warmed up! Dumping and resetting stats!" 391 m5.stats.dump() 392 m5.stats.reset() 393 394 exit_event = m5.simulate() 395 exit_cause = exit_event.getCause() 396 397 if exit_cause == "simpoint starting point found": 398 print "Done running SimPoint!" 399 sys.exit(exit_event.getCode()) 400 401 print 'Exiting @ tick %i because %s' % (m5.curTick(), exit_cause) 402 sys.exit(exit_event.getCode()) 403 404def repeatSwitch(testsys, repeat_switch_cpu_list, maxtick, switch_freq): 405 print "starting switch loop" 406 while True: 407 exit_event = m5.simulate(switch_freq) 408 exit_cause = exit_event.getCause() 409 410 if exit_cause != "simulate() limit reached": 411 return exit_event 412 413 m5.switchCpus(testsys, repeat_switch_cpu_list) 414 415 tmp_cpu_list = [] 416 for old_cpu, new_cpu in repeat_switch_cpu_list: 417 tmp_cpu_list.append((new_cpu, old_cpu)) 418 repeat_switch_cpu_list = tmp_cpu_list 419 420 if (maxtick - m5.curTick()) <= switch_freq: 421 exit_event = m5.simulate(maxtick - m5.curTick()) 422 return exit_event 423 424def run(options, root, testsys, cpu_class): 425 if options.checkpoint_dir: 426 cptdir = options.checkpoint_dir 427 elif m5.options.outdir: 428 cptdir = m5.options.outdir 429 else: 430 cptdir = getcwd() 431 432 if options.fast_forward and options.checkpoint_restore != None: 433 fatal("Can't specify both --fast-forward and --checkpoint-restore") 434 435 if options.standard_switch and not options.caches: 436 fatal("Must specify --caches when using --standard-switch") 437 438 if options.standard_switch and options.repeat_switch: 439 fatal("Can't specify both --standard-switch and --repeat-switch") 440 441 if options.repeat_switch and options.take_checkpoints: 442 fatal("Can't specify both --repeat-switch and --take-checkpoints") 443 444 np = options.num_cpus 445 switch_cpus = None 446 447 if options.prog_interval: 448 for i in xrange(np): 449 testsys.cpu[i].progress_interval = options.prog_interval 450 451 if options.maxinsts: 452 for i in xrange(np): 453 testsys.cpu[i].max_insts_any_thread = options.maxinsts 454 455 if cpu_class: 456 switch_cpus = [cpu_class(switched_out=True, cpu_id=(i)) 457 for i in xrange(np)] 458 459 for i in xrange(np): 460 if options.fast_forward: 461 testsys.cpu[i].max_insts_any_thread = int(options.fast_forward) 462 switch_cpus[i].system = testsys 463 switch_cpus[i].workload = testsys.cpu[i].workload 464 switch_cpus[i].clk_domain = testsys.cpu[i].clk_domain 465 # simulation period 466 if options.maxinsts: 467 switch_cpus[i].max_insts_any_thread = options.maxinsts 468 # Add checker cpu if selected 469 if options.checker: 470 switch_cpus[i].addCheckerCpu() 471 472 testsys.switch_cpus = switch_cpus 473 switch_cpu_list = [(testsys.cpu[i], switch_cpus[i]) for i in xrange(np)] 474 475 if options.repeat_switch: 476 switch_class = getCPUClass(options.cpu_type)[0] 477 if switch_class.require_caches() and \ 478 not options.caches: 479 print "%s: Must be used with caches" % str(switch_class) 480 sys.exit(1) 481 if not switch_class.support_take_over(): 482 print "%s: CPU switching not supported" % str(switch_class) 483 sys.exit(1) 484 485 repeat_switch_cpus = [switch_class(switched_out=True, \ 486 cpu_id=(i)) for i in xrange(np)] 487 488 for i in xrange(np): 489 repeat_switch_cpus[i].system = testsys 490 repeat_switch_cpus[i].workload = testsys.cpu[i].workload 491 repeat_switch_cpus[i].clk_domain = testsys.cpu[i].clk_domain 492 493 if options.maxinsts: 494 repeat_switch_cpus[i].max_insts_any_thread = options.maxinsts 495 496 if options.checker: 497 repeat_switch_cpus[i].addCheckerCpu() 498 499 testsys.repeat_switch_cpus = repeat_switch_cpus 500 501 if cpu_class: 502 repeat_switch_cpu_list = [(switch_cpus[i], repeat_switch_cpus[i]) 503 for i in xrange(np)] 504 else: 505 repeat_switch_cpu_list = [(testsys.cpu[i], repeat_switch_cpus[i]) 506 for i in xrange(np)] 507 508 if options.standard_switch: 509 switch_cpus = [TimingSimpleCPU(switched_out=True, cpu_id=(i)) 510 for i in xrange(np)] 511 switch_cpus_1 = [DerivO3CPU(switched_out=True, cpu_id=(i)) 512 for i in xrange(np)] 513 514 for i in xrange(np): 515 switch_cpus[i].system = testsys 516 switch_cpus_1[i].system = testsys 517 switch_cpus[i].workload = testsys.cpu[i].workload 518 switch_cpus_1[i].workload = testsys.cpu[i].workload 519 switch_cpus[i].clk_domain = testsys.cpu[i].clk_domain 520 switch_cpus_1[i].clk_domain = testsys.cpu[i].clk_domain 521 522 # if restoring, make atomic cpu simulate only a few instructions 523 if options.checkpoint_restore != None: 524 testsys.cpu[i].max_insts_any_thread = 1 525 # Fast forward to specified location if we are not restoring 526 elif options.fast_forward: 527 testsys.cpu[i].max_insts_any_thread = int(options.fast_forward) 528 # Fast forward to a simpoint (warning: time consuming) 529 elif options.simpoint: 530 if testsys.cpu[i].workload[0].simpoint == 0: 531 fatal('simpoint not found') 532 testsys.cpu[i].max_insts_any_thread = \ 533 testsys.cpu[i].workload[0].simpoint 534 # No distance specified, just switch 535 else: 536 testsys.cpu[i].max_insts_any_thread = 1 537 538 # warmup period 539 if options.warmup_insts: 540 switch_cpus[i].max_insts_any_thread = options.warmup_insts 541 542 # simulation period 543 if options.maxinsts: 544 switch_cpus_1[i].max_insts_any_thread = options.maxinsts 545 546 # attach the checker cpu if selected 547 if options.checker: 548 switch_cpus[i].addCheckerCpu() 549 switch_cpus_1[i].addCheckerCpu() 550 551 testsys.switch_cpus = switch_cpus 552 testsys.switch_cpus_1 = switch_cpus_1 553 switch_cpu_list = [(testsys.cpu[i], switch_cpus[i]) for i in xrange(np)] 554 switch_cpu_list1 = [(switch_cpus[i], switch_cpus_1[i]) for i in xrange(np)] 555 556 # set the checkpoint in the cpu before m5.instantiate is called 557 if options.take_checkpoints != None and \ 558 (options.simpoint or options.at_instruction): 559 offset = int(options.take_checkpoints) 560 # Set an instruction break point 561 if options.simpoint: 562 for i in xrange(np): 563 if testsys.cpu[i].workload[0].simpoint == 0: 564 fatal('no simpoint for testsys.cpu[%d].workload[0]', i) 565 checkpoint_inst = int(testsys.cpu[i].workload[0].simpoint) + offset 566 testsys.cpu[i].max_insts_any_thread = checkpoint_inst 567 # used for output below 568 options.take_checkpoints = checkpoint_inst 569 else: 570 options.take_checkpoints = offset 571 # Set all test cpus with the right number of instructions 572 # for the upcoming simulation 573 for i in xrange(np): 574 testsys.cpu[i].max_insts_any_thread = offset 575 576 if options.take_simpoint_checkpoints != None: 577 simpoints, interval_length = parseSimpointAnalysisFile(options, testsys) 578 579 checkpoint_dir = None 580 if options.checkpoint_restore: 581 cpt_starttick, checkpoint_dir = findCptDir(options, cptdir, testsys) 582 m5.instantiate(checkpoint_dir) 583 584 # Initialization is complete. If we're not in control of simulation 585 # (that is, if we're a slave simulator acting as a component in another 586 # 'master' simulator) then we're done here. The other simulator will 587 # call simulate() directly. --initialize-only is used to indicate this. 588 if options.initialize_only: 589 return 590 591 # Handle the max tick settings now that tick frequency was resolved 592 # during system instantiation 593 # NOTE: the maxtick variable here is in absolute ticks, so it must 594 # include any simulated ticks before a checkpoint 595 explicit_maxticks = 0 596 maxtick_from_abs = m5.MaxTick 597 maxtick_from_rel = m5.MaxTick 598 maxtick_from_maxtime = m5.MaxTick 599 if options.abs_max_tick: 600 maxtick_from_abs = options.abs_max_tick 601 explicit_maxticks += 1 602 if options.rel_max_tick: 603 maxtick_from_rel = options.rel_max_tick 604 if options.checkpoint_restore: 605 # NOTE: this may need to be updated if checkpoints ever store 606 # the ticks per simulated second 607 maxtick_from_rel += cpt_starttick 608 if options.at_instruction or options.simpoint: 609 warn("Relative max tick specified with --at-instruction or" \ 610 " --simpoint\n These options don't specify the " \ 611 "checkpoint start tick, so assuming\n you mean " \ 612 "absolute max tick") 613 explicit_maxticks += 1 614 if options.maxtime: 615 maxtick_from_maxtime = m5.ticks.fromSeconds(options.maxtime) 616 explicit_maxticks += 1 617 if explicit_maxticks > 1: 618 warn("Specified multiple of --abs-max-tick, --rel-max-tick, --maxtime."\ 619 " Using least") 620 maxtick = min([maxtick_from_abs, maxtick_from_rel, maxtick_from_maxtime]) 621 622 if options.checkpoint_restore != None and maxtick < cpt_starttick: 623 fatal("Bad maxtick (%d) specified: " \ 624 "Checkpoint starts starts from tick: %d", maxtick, cpt_starttick) 625 626 if options.standard_switch or cpu_class: 627 if options.standard_switch: 628 print "Switch at instruction count:%s" % \ 629 str(testsys.cpu[0].max_insts_any_thread) 630 exit_event = m5.simulate() 631 elif cpu_class and options.fast_forward: 632 print "Switch at instruction count:%s" % \ 633 str(testsys.cpu[0].max_insts_any_thread) 634 exit_event = m5.simulate() 635 else: 636 print "Switch at curTick count:%s" % str(10000) 637 exit_event = m5.simulate(10000) 638 print "Switched CPUS @ tick %s" % (m5.curTick()) 639 640 m5.switchCpus(testsys, switch_cpu_list) 641 642 if options.standard_switch: 643 print "Switch at instruction count:%d" % \ 644 (testsys.switch_cpus[0].max_insts_any_thread) 645 646 #warmup instruction count may have already been set 647 if options.warmup_insts: 648 exit_event = m5.simulate() 649 else: 650 exit_event = m5.simulate(options.standard_switch) 651 print "Switching CPUS @ tick %s" % (m5.curTick()) 652 print "Simulation ends instruction count:%d" % \ 653 (testsys.switch_cpus_1[0].max_insts_any_thread) 654 m5.switchCpus(testsys, switch_cpu_list1) 655 656 # If we're taking and restoring checkpoints, use checkpoint_dir 657 # option only for finding the checkpoints to restore from. This 658 # lets us test checkpointing by restoring from one set of 659 # checkpoints, generating a second set, and then comparing them. 660 if (options.take_checkpoints or options.take_simpoint_checkpoints) \ 661 and options.checkpoint_restore: 662 663 if m5.options.outdir: 664 cptdir = m5.options.outdir 665 else: 666 cptdir = getcwd() 667 668 if options.take_checkpoints != None : 669 # Checkpoints being taken via the command line at <when> and at 670 # subsequent periods of <period>. Checkpoint instructions 671 # received from the benchmark running are ignored and skipped in 672 # favor of command line checkpoint instructions. 673 exit_event = scriptCheckpoints(options, maxtick, cptdir) 674 675 # Take SimPoint checkpoints 676 elif options.take_simpoint_checkpoints != None: 677 takeSimpointCheckpoints(simpoints, interval_length, cptdir) 678 679 # Restore from SimPoint checkpoints 680 elif options.restore_simpoint_checkpoint != None: 681 restoreSimpointCheckpoint() 682 683 else: 684 if options.fast_forward: 685 m5.stats.reset() 686 print "**** REAL SIMULATION ****" 687 688 # If checkpoints are being taken, then the checkpoint instruction 689 # will occur in the benchmark code it self. 690 if options.repeat_switch and maxtick > options.repeat_switch: 691 exit_event = repeatSwitch(testsys, repeat_switch_cpu_list, 692 maxtick, options.repeat_switch) 693 else: 694 exit_event = benchCheckpoints(options, maxtick, cptdir) 695 696 print 'Exiting @ tick %i because %s' % (m5.curTick(), exit_event.getCause()) 697 if options.checkpoint_at_end: 698 m5.checkpoint(joinpath(cptdir, "cpt.%d")) 699 700 if not m5.options.interactive: 701 sys.exit(exit_event.getCode()) 702