parser.add_option("--simpoint-interval", type="int", default=10000000,
help="SimPoint interval in num of instructions")
parser.add_option("--clock", action="store", type="string", default='2GHz')
+ parser.add_option("--sys-clock", action="store", type="string",
+ default='1GHz',
+ help = """Top-level clock for blocks running at system
+ speed""")
parser.add_option("--cpu-clock", action="store", type="string",
default='2GHz',
help="Clock for blocks running at CPU speed")
else:
fatal("Incapable of building %s full system!", buildEnv['TARGET_ISA'])
+test_sys.clock = options.sys_clock
+
if options.kernel is not None:
test_sys.kernel = binary(options.kernel)
drive_sys = makeArmSystem(drive_mem_mode, options.machine_type,
DriveMemClass, bm[1])
+ drive_sys.clock = options.sys_clock
+
drive_sys.cpu = DriveCPUClass(cpu_id=0)
drive_sys.cpu.createThreads()
drive_sys.cpu.createInterruptController()
system = System(funcmem = SimpleMemory(in_addr_map = False),
funcbus = NoncoherentBus(),
physmem = SimpleMemory(latency = "100ns"))
+system.clock = options.sys_clock
def make_level(spec, prototypes, attach_obj, attach_port):
fanout = spec[0]
# M5 memory size == Ruby memory size checks
#
system = System(physmem = SimpleMemory())
-
+system.clock = options.sys_clock
#
# Create the ruby random tester
#
else:
fatal("incapable of building non-alpha or non-x86 full system!")
+system.clock = options.sys_clock
+
if options.kernel is not None:
system.kernel = binary(options.kernel)
funcmem = SimpleMemory(in_addr_map = False),
funcbus = NoncoherentBus(),
physmem = SimpleMemory())
+system.clock = options.sys_clock
if options.num_dmas > 0:
dmas = [ MemTest(atomic = False,
# create the desired simulated system
system = System(cpu = cpus,
physmem = SimpleMemory())
+system.clock = options.sys_clock
Ruby.create_system(options, system)
# M5 memory size == Ruby memory size checks
#
system = System(tester = tester, physmem = SimpleMemory())
+system.clock = options.sys_clock
Ruby.create_system(options, system)
system = System(cpu = [CPUClass(cpu_id=i) for i in xrange(np)],
physmem = MemClass(range=AddrRange("512MB")),
mem_mode = test_mem_mode)
+system.clock = options.sys_clock
# Sanity check
if options.fastmem:
system = System(cpu = all_cpus, l1_ = all_l1s, l1bus_ = all_l1buses,
physmem = SimpleMemory(),
membus = CoherentBus(clock = busFrequency))
+system.clock = '1GHz'
system.toL2bus = CoherentBus(clock = busFrequency)
system.l2 = L2(size = options.l2size, assoc = 8)
# ----------------------
system = System(cpu = cpus, physmem = SimpleMemory(),
membus = CoherentBus(clock = busFrequency))
+system.clock = '1GHz'
system.toL2bus = CoherentBus(clock = busFrequency)
system.l2 = L2(size = options.l2size, assoc = 8)
cxx_header = "sim/system.hh"
system_port = MasterPort("System port")
- # Override the clock from the ClockedObject which looks at the
- # parent clock by default. The 1 GHz default system clock serves
- # as a start for the modules that rely on the parent to provide
- # the clock.
- clock = '1GHz'
-
@classmethod
def export_method_cxx_predecls(cls, code):
code('#include "sim/system.hh"')
Arguments:
system -- System to initialize.
"""
+ system.clock = '1GHz'
system.cpu = self.create_cpus()
if _have_kvm_support and \
physmem = DDR3_1600_x64(),
membus = CoherentBus(),
mem_mode = "timing")
+system.clock = '1GHz'
system.system_port = system.membus.slave
system.physmem.port = system.membus.master
# create the interrupt controller
funcmem = SimpleMemory(in_addr_map = False),
physmem = SimpleMemory(null = True),
funcbus = NoncoherentBus())
+system.clock = options.sys_clock
Ruby.create_system(options, system)
funcbus = NoncoherentBus(),
physmem = SimpleMemory(),
membus = CoherentBus(width=16))
+system.clock = '1GHz'
# l2cache & bus
system.toL2Bus = CoherentBus(clock="2GHz", width=16)
physmem = DDR3_1600_x64(),
membus = CoherentBus(),
mem_mode = "timing")
+system.clock = '1GHz'
system.system_port = system.membus.slave
system.physmem.port = system.membus.master
cpu.connectAllPorts(system.membus)
# system simulated
system = System(cpu = cpus, physmem = ruby_memory, membus = CoherentBus(),
mem_mode = "timing")
+system.clock = '1GHz'
for cpu in cpus:
# create the interrupt controller
physmem = DDR3_1600_x64(),
membus = CoherentBus(),
mem_mode = "timing")
+system.clock = '1GHz'
# l2cache & bus
system.toL2Bus = CoherentBus(clock = '2GHz')
physmem = ruby_memory,
membus = CoherentBus(),
mem_mode = "timing")
+system.clock = '1GHz'
system.physmem.port = system.membus.master
# create the interrupt controller
cpu.createInterruptController()
physmem = DDR3_1600_x64(),
membus = CoherentBus(),
mem_mode = "timing")
+system.clock = '1GHz'
system.system_port = system.membus.slave
system.physmem.port = system.membus.master
# create the interrupt controller
wakeup_frequency = 10, num_cpus = options.num_cpus)
system = System(tester = tester, physmem = SimpleMemory(null = True))
+system.clock = options.sys_clock
Ruby.create_system(options, system)
system = System(cpu = AtomicSimpleCPU(cpu_id=0),
physmem = SimpleMemory(),
membus = CoherentBus())
+system.clock = '1GHz'
system.system_port = system.membus.slave
system.physmem.port = system.membus.master
system.cpu.addCheckerCpu()
# system simulated
system = System(cpu = cpus, physmem = ruby_memory, membus = CoherentBus())
+system.clock = '1GHz'
# add L1 caches
for cpu in cpus:
system = System(cpu = cpus,
physmem = SimpleMemory(range = AddrRange('1024MB')),
membus = CoherentBus())
-
+system.clock = '1GHz'
# l2cache & bus
system.toL2Bus = CoherentBus(clock = '2GHz')
system.l2c = L2Cache(clock = '2GHz', size='4MB', assoc=8)
system = System(cpu = AtomicSimpleCPU(cpu_id=0),
physmem = SimpleMemory(),
membus = CoherentBus())
+system.clock = '1GHz'
system.system_port = system.membus.slave
system.physmem.port = system.membus.master
# create the interrupt controller
# system simulated
system = System(cpu = cpus, physmem = SimpleMemory())
+system.clock = options.sys_clock
Ruby.create_system(options, system)
# system simulated
system = System(cpu = cpus, physmem = SimpleMemory(), membus = CoherentBus())
+system.clock = '1GHz'
# l2cache & bus
system.toL2Bus = CoherentBus(clock = '2GHz')
cpu = TimingSimpleCPU(cpu_id=0)
system = System(cpu = cpu, physmem = SimpleMemory(null = True))
+system.clock = options.sys_clock
Ruby.create_system(options, system)
physmem = SimpleMemory(),
membus = CoherentBus(),
mem_mode = "timing")
+system.clock = '1GHz'
system.system_port = system.membus.slave
system.physmem.port = system.membus.master
# create the interrupt controller
# system simulated
system = System(cpu = cpu, physmem = DDR3_1600_x64(),
membus = NoncoherentBus(width = 16))
+system.clock = '1GHz'
# add a communication monitor
system.monitor = CommMonitor()
# system simulated
system = System(cpu = cpu, physmem = SimpleMemory(),
membus = NoncoherentBus(width = 16))
+system.clock = '1GHz'
# add a communication monitor, and also trace all the packets
system.monitor = CommMonitor(trace_file = "monitor.ptrc.gz")
test_sys = makeLinuxAlphaSystem('atomic', SimpleMemory,
SysConfig('netperf-stream-client.rcS'))
+test_sys.clock = '1GHz'
test_sys.cpu = AtomicSimpleCPU(cpu_id=0)
# create the interrupt controller
test_sys.cpu.createInterruptController()
drive_sys = makeLinuxAlphaSystem('atomic', SimpleMemory,
SysConfig('netperf-server.rcS'))
+drive_sys.clock = '1GHz'
drive_sys.cpu = AtomicSimpleCPU(cpu_id=0)
# create the interrupt controller
drive_sys.cpu.createInterruptController()