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
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:
| 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
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:
|
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())
| 600 testsys.cpu[i].max_insts_any_thread = offset
601
602 if options.take_simpoint_checkpoints != None:
603 simpoints, interval_length = parseSimpointAnalysisFile(options, testsys)
604
605 checkpoint_dir = None
606 if options.checkpoint_restore:
607 cpt_starttick, checkpoint_dir = findCptDir(options, cptdir, testsys)
608 root.apply_config(options.param)
609 m5.instantiate(checkpoint_dir)
610
611 # Initialization is complete. If we're not in control of simulation
612 # (that is, if we're a slave simulator acting as a component in another
613 # 'master' simulator) then we're done here. The other simulator will
614 # call simulate() directly. --initialize-only is used to indicate this.
615 if options.initialize_only:
616 return
617
618 # Handle the max tick settings now that tick frequency was resolved
619 # during system instantiation
620 # NOTE: the maxtick variable here is in absolute ticks, so it must
621 # include any simulated ticks before a checkpoint
622 explicit_maxticks = 0
623 maxtick_from_abs = m5.MaxTick
624 maxtick_from_rel = m5.MaxTick
625 maxtick_from_maxtime = m5.MaxTick
626 if options.abs_max_tick:
627 maxtick_from_abs = options.abs_max_tick
628 explicit_maxticks += 1
629 if options.rel_max_tick:
630 maxtick_from_rel = options.rel_max_tick
631 if options.checkpoint_restore:
632 # NOTE: this may need to be updated if checkpoints ever store
633 # the ticks per simulated second
634 maxtick_from_rel += cpt_starttick
635 if options.at_instruction or options.simpoint:
636 warn("Relative max tick specified with --at-instruction or" \
637 " --simpoint\n These options don't specify the " \
638 "checkpoint start tick, so assuming\n you mean " \
639 "absolute max tick")
640 explicit_maxticks += 1
641 if options.maxtime:
642 maxtick_from_maxtime = m5.ticks.fromSeconds(options.maxtime)
643 explicit_maxticks += 1
644 if explicit_maxticks > 1:
645 warn("Specified multiple of --abs-max-tick, --rel-max-tick, --maxtime."\
646 " Using least")
647 maxtick = min([maxtick_from_abs, maxtick_from_rel, maxtick_from_maxtime])
648
649 if options.checkpoint_restore != None and maxtick < cpt_starttick:
650 fatal("Bad maxtick (%d) specified: " \
651 "Checkpoint starts starts from tick: %d", maxtick, cpt_starttick)
652
653 if options.standard_switch or cpu_class:
654 if options.standard_switch:
655 print("Switch at instruction count:%s" %
656 str(testsys.cpu[0].max_insts_any_thread))
657 exit_event = m5.simulate()
658 elif cpu_class and options.fast_forward:
659 print("Switch at instruction count:%s" %
660 str(testsys.cpu[0].max_insts_any_thread))
661 exit_event = m5.simulate()
662 else:
663 print("Switch at curTick count:%s" % str(10000))
664 exit_event = m5.simulate(10000)
665 print("Switched CPUS @ tick %s" % (m5.curTick()))
666
667 m5.switchCpus(testsys, switch_cpu_list)
668
669 if options.standard_switch:
670 print("Switch at instruction count:%d" %
671 (testsys.switch_cpus[0].max_insts_any_thread))
672
673 #warmup instruction count may have already been set
674 if options.warmup_insts:
675 exit_event = m5.simulate()
676 else:
677 exit_event = m5.simulate(options.standard_switch)
678 print("Switching CPUS @ tick %s" % (m5.curTick()))
679 print("Simulation ends instruction count:%d" %
680 (testsys.switch_cpus_1[0].max_insts_any_thread))
681 m5.switchCpus(testsys, switch_cpu_list1)
682
683 # If we're taking and restoring checkpoints, use checkpoint_dir
684 # option only for finding the checkpoints to restore from. This
685 # lets us test checkpointing by restoring from one set of
686 # checkpoints, generating a second set, and then comparing them.
687 if (options.take_checkpoints or options.take_simpoint_checkpoints) \
688 and options.checkpoint_restore:
689
690 if m5.options.outdir:
691 cptdir = m5.options.outdir
692 else:
693 cptdir = getcwd()
694
695 if options.take_checkpoints != None :
696 # Checkpoints being taken via the command line at <when> and at
697 # subsequent periods of <period>. Checkpoint instructions
698 # received from the benchmark running are ignored and skipped in
699 # favor of command line checkpoint instructions.
700 exit_event = scriptCheckpoints(options, maxtick, cptdir)
701
702 # Take SimPoint checkpoints
703 elif options.take_simpoint_checkpoints != None:
704 takeSimpointCheckpoints(simpoints, interval_length, cptdir)
705
706 # Restore from SimPoint checkpoints
707 elif options.restore_simpoint_checkpoint != None:
708 restoreSimpointCheckpoint()
709
710 else:
711 if options.fast_forward:
712 m5.stats.reset()
713 print("**** REAL SIMULATION ****")
714
715 # If checkpoints are being taken, then the checkpoint instruction
716 # will occur in the benchmark code it self.
717 if options.repeat_switch and maxtick > options.repeat_switch:
718 exit_event = repeatSwitch(testsys, repeat_switch_cpu_list,
719 maxtick, options.repeat_switch)
720 else:
721 exit_event = benchCheckpoints(options, maxtick, cptdir)
722
723 print('Exiting @ tick %i because %s' %
724 (m5.curTick(), exit_event.getCause()))
725 if options.checkpoint_at_end:
726 m5.checkpoint(joinpath(cptdir, "cpt.%d"))
727
728 if exit_event.getCode() != 0:
729 print("Simulated exit code not 0! Exit code is", exit_event.getCode())
|