ruby: reorganized ruby python configuration

Reorganized ruby python configuration so that protocol and ruby memory system
configuration code can be shared by multiple front-end configuration files
(i.e. memory tester, full system, and hopefully the regression tester).  This
code works for memory tester, but have not tested fs mode.

1 files changed, 20 insertions, 109 deletions

diff --git a/configs/example/memtest-ruby.py b/configs/example/memtest-ruby.py
index c610a1c62..6a018d354 100644
--- a/configs/example/memtest-ruby.py
+++ b/configs/example/memtest-ruby.py
@@ -34,6 +34,17 @@ from m5.defines import buildEnv
 from m5.util import addToPath
 import os, optparse, sys
 addToPath('../common')
+addToPath('../ruby')
+
+import Ruby
+
+if buildEnv['FULL_SYSTEM']:
+    panic("This script requires system-emulation mode (*_SE).")
+
+# Get paths we might need.  It's expected this file is in m5/configs/example.
+config_path = os.path.dirname(os.path.abspath(__file__))
+config_root = os.path.dirname(config_path)
+m5_root = os.path.dirname(config_root)
 
 parser = optparse.OptionParser()
 
@@ -43,13 +54,6 @@ parser.add_option("-b", "--blocking", action="store_true",
                   help="Use blocking caches")
 parser.add_option("-l", "--maxloads", metavar="N", default=0,
                   help="Stop after N loads")
-parser.add_option("-m", "--maxtick", type="int", default=m5.MaxTick,
-                  metavar="T",
-                  help="Stop after T ticks")
-
-parser.add_option("-t", "--testers", type="int", metavar="N", default=1,
-                  help="number of testers/cores")
-
 parser.add_option("-f", "--functional", type="int", default=0,
                   metavar="PCT",
                   help="Target percentage of functional accesses "
@@ -64,6 +68,8 @@ parser.add_option("--progress", type="int", default=1000,
                   help="Progress message interval "
                   "[default: %default]")
 
+execfile(os.path.join(config_root, "common", "Options.py"))
+
 (options, args) = parser.parse_args()
 
 if args:
@@ -72,126 +78,31 @@ if args:
 
 block_size = 64
 
-if options.testers > block_size:
+if options.num_cpus > block_size:
      print "Error: Number of testers %d limited to %d because of false sharing" \
-           % (options.testers, block_size)
+           % (options.num_cpus, block_size)
      sys.exit(1)
 
 cpus = [ MemTest(atomic=options.atomic, max_loads=options.maxloads, \
                  percent_functional=options.functional, \
                  percent_uncacheable=options.uncacheable, \
                  progress_interval=options.progress) \
-         for i in xrange(options.testers) ]
+         for i in xrange(options.num_cpus) ]
 
 system = System(cpu = cpus,
                 funcmem = PhysicalMemory(),
                 physmem = PhysicalMemory())
 
-class L1Cache(RubyCache):
-    assoc = 2
-    latency = 3
-    size = 32768
+system.ruby = Ruby.create_system(options, system.physmem)
 
-class L2Cache(RubyCache):
-    assoc = 16
-    latency = 15
-    size = 1048576
+assert(len(cpus) == len(system.ruby.cpu_ruby_ports))
 
-#
-# The ruby network creation expects the list of nodes in the system to be
-# consistent with the NetDest list.  Therefore the l1 controller nodes must be
-# listed before the directory nodes and directory nodes before dma nodes, etc.
-#
-l1_cntrl_nodes = []
-dir_cntrl_nodes = []
-dma_cntrl_nodes = []
-
-#
-# Must create the individual controllers before the network to ensure the
-# controller constructors are called before the network constructor
-#
 for (i, cpu) in enumerate(cpus):
     #
-    # First create the Ruby objects associated with this cpu
-    # Eventually this code should go in a python file specific to the
-    # MOESI_hammer protocol
-    #
-    l1i_profiler = CacheProfiler(description = ("l1i_%s_profiler" % i))
-    l1i_cache = L1Cache(cache_profiler = l1i_profiler)
-
-    l1d_profiler = CacheProfiler(description = ("l1d_%s_profiler" % i))
-    l1d_cache = L1Cache(cache_profiler = l1d_profiler)
-
-    l2_profiler = CacheProfiler(description = ("l2_%s_profiler" % i))
-    l2_cache = L2Cache(cache_profiler = l2_profiler)
-
-    cpu_seq = RubySequencer(icache = l1i_cache,
-                            dcache = l1d_cache,
-                            funcmem_port = system.physmem.port)
-
-    l1_cntrl = L1Cache_Controller(version = i,
-                                  sequencer = cpu_seq,
-                                  L1IcacheMemory = l1i_cache,
-                                  L1DcacheMemory = l1d_cache,
-                                  L2cacheMemory = l2_cache)
-
-    mem_cntrl = RubyMemoryControl(version = i)
-    
-    dir_cntrl = Directory_Controller(version = i,
-                                     directory = RubyDirectoryMemory(),
-                                     memBuffer = mem_cntrl)
-
-    dma_cntrl = DMA_Controller(version = i,
-                               dma_sequencer = DMASequencer())
-    #
-    # As noted above: Two independent list are track to maintain the order of
-    # nodes/controllers assumed by the ruby network
+    # Tie the memtester ports to the correct system ports
     #
-    l1_cntrl_nodes.append(l1_cntrl)
-    dir_cntrl_nodes.append(dir_cntrl)
-    dma_cntrl_nodes.append(dma_cntrl)
-
-    #
-    # Finally tie the memtester ports to the correct system ports
-    #
-    cpu.test = cpu_seq.port
+    cpu.test = system.ruby.cpu_ruby_ports[i].port
     cpu.functional = system.funcmem.port
-    
-
-#
-# Important: the topology constructor must be called before the network
-# constructor.
-#
-network = SimpleNetwork(topology = makeCrossbar(l1_cntrl_nodes + \
-                                                dir_cntrl_nodes + \
-                                                dma_cntrl_nodes))
-
-mem_size_mb = sum([int(dir_cntrl.directory.size_mb) \
-                   for dir_cntrl in dir_cntrl_nodes])
-
-#
-# determine the number of memory controllers and other memory controller
-# parameters for the profiler
-#
-mcCount = len(dir_cntrl_nodes)
-banksPerRank = dir_cntrl_nodes[0].memBuffer.banks_per_rank
-ranksPerDimm = dir_cntrl_nodes[0].memBuffer.ranks_per_dimm
-dimmsPerChannel = dir_cntrl_nodes[0].memBuffer.dimms_per_channel
-
-ruby_profiler = RubyProfiler(mem_cntrl_count = mcCount,
-                             banks_per_rank = banksPerRank,
-                             ranks_per_dimm = ranksPerDimm,
-                             dimms_per_channel = dimmsPerChannel)
-
-system.ruby = RubySystem(clock = '1GHz',
-                         network = network,
-                         profiler = ruby_profiler,
-                         tracer = RubyTracer(),
-                         debug = RubyDebug(filter_string = 'none',
-                                           verbosity_string = 'none',
-                                           protocol_trace = False),
-                         mem_size_mb = mem_size_mb)
-
 
 # -----------------------
 # run simulation