def init_system(self, system):
"""Initialize a system.
Arguments:
system -- System to initialize.
"""
self.create_clk_src(system)
system.cpu = self.create_cpus(system.cpu_clk_domain)
if _have_kvm_support and \
any([isinstance(c, BaseKvmCPU) for c in system.cpu]):
self.init_kvm(system)
if self.use_ruby:
# Add the ruby specific and protocol specific options
parser = optparse.OptionParser()
Options.addCommonOptions(parser)
Ruby.define_options(parser)
(options, args) = parser.parse_args()
# Set the default cache size and associativity to be very
# small to encourage races between requests and writebacks.
options.l1d_size="32kB"
options.l1i_size="32kB"
options.l2_size="4MB"
options.l1d_assoc=4
options.l1i_assoc=2
options.l2_assoc=8
options.num_cpus = self.num_cpus
options.num_dirs = 2
bootmem = getattr(system, 'bootmem', None)
Ruby.create_system(options, True, system, system.iobus,
system._dma_ports, bootmem)
# Create a seperate clock domain for Ruby
system.ruby.clk_domain = SrcClockDomain(
clock = options.ruby_clock,
voltage_domain = system.voltage_domain)
for i, cpu in enumerate(system.cpu):
if not cpu.switched_out:
cpu.createInterruptController()
cpu.connectCachedPorts(system.ruby._cpu_ports[i])
else:
sha_bus = self.create_caches_shared(system)
for cpu in system.cpu:
self.init_cpu(system, cpu, sha_bus)
from ruby import Ruby
from common import Options
parser = optparse.OptionParser()
Options.addCommonOptions(parser)
# add the gpu specific options expected by the the gpu and gpu_RfO
parser.add_option("-u", "--num-compute-units", type="int", default=8, help="number of compute units in the GPU")
parser.add_option("--num-cp", type="int", default=0, help="Number of GPU Command Processors (CP)")
parser.add_option("--simds-per-cu", type="int", default=4, help="SIMD units" "per CU")
parser.add_option("--wf-size", type="int", default=64, help="Wavefront size(in workitems)")
parser.add_option("--wfs-per-simd", type="int", default=10, help="Number of " "WF slots per SIMD")
# Add the ruby specific and protocol specific options
Ruby.define_options(parser)
(options, args) = parser.parse_args()
#
# Set the default cache size and associativity to be very small to encourage
# races between requests and writebacks.
#
options.l1d_size = "256B"
options.l1i_size = "256B"
options.l2_size = "512B"
options.l3_size = "1kB"
options.l1d_assoc = 2
options.l1i_assoc = 2
options.l2_assoc = 2
options.l3_assoc = 2
print("Using cpu: {}".format(cpu))
exit_event = m5.simulate(opts.abs_max_tick)
# While there is still something to do in the guest keep executing.
while exit_event.getCause() != "m5_exit instruction encountered":
# If the user pressed ctrl-c on the host, then we really should exit
if exit_event.getCause() == "user interrupt received":
print("User interrupt. Exiting")
break
if exit_event.getCause() == "simulate() limit reached":
break
elif "checkpoint" in exit_event.getCause():
m5.checkpoint(opts.checkpoint_dir)
break
elif "switchcpu" in exit_event.getCause():
system.switchCpus(system.cpu, system.warmupCpu)
else:
break
print('Exiting @ tick %i because %s' %
(m5.curTick(), exit_event.getCause()))
if __name__ == "__m5_main__":
addRunFSOptions(SimpleOpts)
addGPUOptions(SimpleOpts)
Options.addNoISAOptions(SimpleOpts)
Ruby.define_options(SimpleOpts)
runFullSystem()
for i in xrange(len(drive_sys.mem_ctrls)):
drive_sys.mem_ctrls[i].port = drive_sys.membus.master
drive_sys.init_param = options.init_param
return drive_sys
# Add options
parser = optparse.OptionParser()
Options.addCommonOptions(parser)
Options.addFSOptions(parser)
# Add the ruby specific and protocol specific options
if '--ruby' in sys.argv:
Ruby.define_options(parser)
(options, args) = parser.parse_args()
if args:
print("Error: script doesn't take any positional arguments")
sys.exit(1)
# system under test can be any CPU
(TestCPUClass, test_mem_mode, FutureClass) = Simulation.setCPUClass(options)
# Match the memories with the CPUs, based on the options for the test system
TestMemClass = Simulation.setMemClass(options)
if options.benchmark:
try:
def main():
parser = argparse.ArgumentParser()
parser.add_argument("--dtb",
type=str,
default=None,
help="DTB file to load")
parser.add_argument("--kernel",
type=str,
default=default_kernel,
help="Linux kernel")
parser.add_argument("--disk-image",
type=str,
default=default_disk,
help="Disk to instantiate")
parser.add_argument(
"--root-device",
type=str,
default=default_root_device,
help="OS device name for root partition (default: {})".format(
default_root_device))
parser.add_argument("--script",
type=str,
default="",
help="Linux bootscript")
parser.add_argument("--cpu",
choices=list(cpu_types.keys()),
default="minor",
help="CPU model to use")
parser.add_argument("--cpu-freq", type=str, default="4GHz")
parser.add_argument("-n", "--num-cpus", type=int, default=1)
parser.add_argument("--checkpoint", action="store_true")
parser.add_argument("--restore", type=str, default=None)
parser.add_argument("--mem-type",
default="DDR3_1600_8x8",
choices=ObjectList.mem_list.get_names(),
help="type of memory to use")
parser.add_argument("--mem-channels",
type=int,
default=1,
help="number of memory channels")
parser.add_argument("--mem-ranks",
type=int,
default=None,
help="number of memory ranks per channel")
parser.add_argument(
"--mem-size",
action="store",
type=str,
default="2GiB",
help="Specify the physical memory size (single memory)")
parser.add_argument("--enable-dram-powerdown",
action="store_true",
help="Enable low-power states in DRAMInterface")
parser.add_argument("--mem-channels-intlv",
type=int,
default=0,
help="Memory channels interleave")
parser.add_argument("--num-dirs", type=int, default=1)
parser.add_argument("--num-l2caches", type=int, default=1)
parser.add_argument("--num-l3caches", type=int, default=1)
parser.add_argument("--l1d_size", type=str, default="64kB")
parser.add_argument("--l1i_size", type=str, default="32kB")
parser.add_argument("--l2_size", type=str, default="2MB")
parser.add_argument("--l3_size", type=str, default="16MB")
parser.add_argument("--l1d_assoc", type=int, default=2)
parser.add_argument("--l1i_assoc", type=int, default=2)
parser.add_argument("--l2_assoc", type=int, default=8)
parser.add_argument("--l3_assoc", type=int, default=16)
parser.add_argument("--cacheline_size", type=int, default=64)
Ruby.define_options(parser)
args = parser.parse_args()
root = Root(full_system=True)
root.system = create(args)
if args.restore is not None:
m5.instantiate(args.restore)
else:
m5.instantiate()
run(args)
