def main():
parser = OptionParser(epilog=__doc__)
Options.addCommonOptions(parser)
Options.addFSOptions(parser)
parser.add_option("--atp-file",
action="append",
type="string",
default=[str(atp_configs_dir / "stream.atp")],
help=".atp file to load in Engine")
parser.add_option("--dtb-gen",
action="store_true",
help="Doesn't run simulation, it generates a DTB only")
parser.add_option("--checkpoint", action="store_true")
args, _ = parser.parse_args()
if args.checkpoint:
script = NamedTemporaryFile()
script.write(b"#!/bin/sh\nm5 checkpoint && m5 readfile | sh\n")
script.flush()
args.script = script.name
args.max_checkpoints = 1
system = create(args)
root = Root(full_system=True, system=system)
if args.dtb_gen:
# No run, autogenerate DTB and exit
system.generateDtb(str(outdir / "system.dtb"))
else:
Simulation.run(args, root, system, None)
def main():
# Add options
parser = optparse.OptionParser()
Options.addCommonOptions(parser)
Options.addFSOptions(parser)
(options, args) = parser.parse_args()
system = build_switch(options)
root = Root(full_system = True, system = system)
Simulation.run(options, root, None, None)
def main():
# Add options
parser = argparse.ArgumentParser()
Options.addCommonOptions(parser)
Options.addFSOptions(parser)
args = parser.parse_args()
system = build_switch(args)
root = Root(full_system=True, system=system)
Simulation.run(args, root, None, None)
def get_options():
parser = optparse.OptionParser()
Options.addCommonOptions(parser)
Options.addSEOptions(parser)
# base output directory to use.
#
# This takes precedence over gem5's built-in outdir option
parser.add_option("--directory", type="str", default=None)
parser.add_option("--ROB", type=int, default=8)
parser.add_option("--IQ", type=int, default=4)
parser.set_defaults(
# Default to writing to program.out in the current working directory
# below, we cd to the simulation output directory
output='./program.out',
errout='./program.err',
mem_size=1024 * 1024 * 1024,
caches=True)
(options, args) = parser.parse_args()
# Always enable caches, DerivO3CPU will not work without it.
if not options.directory:
eprint(
"You must set --directory to the name of an output directory to create"
)
sys.exit(1)
if os.path.exists(options.directory):
eprint("Output directory %s already exists -- refusing to overwrite" %
(options.directory))
sys.exit(1)
# Some features are not supported by this script, but are added to parser by
# Options.addSEOptions and Options.addCommonOptions
# I check for these here to avoid confusion
# If you are failing an assertion here, removing the assertion will not make the option work.
assert (not options.smt)
assert (options.num_cpus == 1)
assert (not options.fastmem)
assert (not options.standard_switch)
assert (not options.repeat_switch)
assert (not options.take_checkpoints)
assert (not options.fast_forward)
assert (not options.maxinsts)
assert (not options.l2cache)
if args:
print("Error: script doesn't take any positional arguments")
sys.exit(1)
return options
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 self.use_ruby:
# Add the ruby specific and protocol specific options
parser = argparse.ArgumentParser()
Options.addCommonOptions(parser)
Ruby.define_options(parser)
args, extra = parser.parse_known_args()
# Set the default cache size and associativity to be very
# small to encourage races between requests and writebacks.
args.l1d_size = "32kB"
args.l1i_size = "32kB"
args.l2_size = "4MB"
args.l1d_assoc = 4
args.l1i_assoc = 2
args.l2_assoc = 8
args.num_cpus = self.num_cpus
args.num_dirs = 2
bootmem = getattr(system, '_bootmem', None)
Ruby.create_system(args, True, system, system.iobus,
system._dma_ports, bootmem)
# Create a seperate clock domain for Ruby
system.ruby.clk_domain = SrcClockDomain(
clock=args.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].in_ports)
else:
sha_bus = self.create_caches_shared(system)
for cpu in system.cpu:
self.init_cpu(system, cpu, sha_bus)
if _have_kvm_support and \
any([isinstance(c, BaseKvmCPU) for c in system.cpu]):
self.init_kvm(system)
self.init_kvm_cpus(system.cpu)
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)
def add_all_options():
parser = optparse.OptionParser()
Options.addCommonOptions(parser)
Options.addSEOptions(parser)
Network.define_options(parser)
# architectural configuration options
parser.add_option("--hybrid-mem", action="store_true")
# spm options
parser.add_option("--spm-page-size",
type="int",
default="512",
help="spm page size in bytes")
parser.add_option("--l1dspm-size", type="string", default="64kB")
# governor options
parser.add_option("--gov-type", type="string", default="Local")
parser.add_option("--local-share", type="float", default="0.75")
parser.add_option("--guest-slot-selection-policy",
type="string",
default="LeastRecentlyUsed")
parser.add_option("--guest-slot-relocation-policy",
type="string",
default="MoveOffChip")
parser.add_option("--uncacheable-spm", action="store_true")
# approx options
parser.add_option("--spm-read-ber",
type="float",
default="-1",
help="read ber for approximate spm reads")
parser.add_option("--spm-write-ber",
type="float",
default="-1",
help="write ber for approximate spm writes")
parser.add_option("--ber-energy-file", type="string", default="")
return parser
from m5.util import addToPath, fatal
addToPath('../')
from ruby import Ruby
from common import Options
from common import Simulation
from common import CacheConfig
from common import CpuConfig
from common import MemConfig
from common.Caches import *
from common.cpu2000 import *
parser = optparse.OptionParser()
Options.addCommonOptions(parser)
Options.addSEOptions(parser)
if '--ruby' in sys.argv:
Ruby.define_options(parser)
else:
fatal("This test is only for FPGA in Ruby. Please set --ruby.\n")
(options, args) = parser.parse_args()
if args:
print "Error: script doesn't take any positional arguments"
sys.exit(1)
numThreads = 1
# Author: Brad Beckmann
#
import m5
from m5.objects import *
from m5.defines import buildEnv
from m5.util import addToPath
import os, optparse, sys
m5.util.addToPath("../configs/")
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
