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