1 files changed, 92 insertions, 44 deletions

diff --git a/src/mem/ruby/system/System.hh b/src/mem/ruby/system/System.hh
index bc493dd16..40c425ad7 100644
--- a/src/mem/ruby/system/System.hh
+++ b/src/mem/ruby/system/System.hh
@@ -41,81 +41,129 @@
 #ifndef SYSTEM_H
 #define SYSTEM_H
 
+#include "mem/ruby/system/RubyPort.hh"
 #include "mem/ruby/common/Global.hh"
 #include "mem/gems_common/Vector.hh"
-#include "mem/ruby/common/Address.hh"
-#include "mem/ruby/config/RubyConfig.hh"
-#include "mem/protocol/MachineType.hh"
-#include "mem/ruby/slicc_interface/AbstractChip.hh"
+#include "mem/ruby/eventqueue/RubyEventQueue.hh"
+#include <map>
 
 class Profiler;
 class Network;
-class Driver;
 class CacheRecorder;
 class Tracer;
 class Sequencer;
-class XactIsolationChecker;
-class XactCommitArbiter;
-class XactVisualizer;
-class TransactionInterfaceManager;
+class DMASequencer;
+class MemoryVector;
+class AbstractController;
+class MessageBuffer;
+class CacheMemory;
+class DirectoryMemory;
+class Topology;
+class MemoryControl;
+
+struct RubyObjConf {
+  string type;
+  string name;
+  vector<string> argv;
+  RubyObjConf(string _type, string _name, vector<string> _argv)
+    : type(_type), name(_name), argv(_argv)
+  {}
+};
 
 class RubySystem {
 public:
-  // Constructors
-  RubySystem();
-  RubySystem(Driver* _driver); // used when driver is already instantiated (e.g. M5's RubyMem)
-
+  static RubySystem* create(const vector <RubyObjConf> & sys_conf);
   // Destructor
   ~RubySystem();
 
+  // config accessors
+  static int getRandomSeed() { return m_random_seed; }
+  static int getRandomization() { return m_randomization; }
+  static int getTechNm() { return m_tech_nm; }
+  static int getFreqMhz() { return m_freq_mhz; }
+  static int getBlockSizeBytes() { return m_block_size_bytes; }
+  static int getBlockSizeBits() { return m_block_size_bits; }
+  static uint64 getMemorySizeBytes() { return m_memory_size_bytes; }
+  static int getMemorySizeBits() { return m_memory_size_bits; }
+
   // Public Methods
-  int getNumProcessors() { return RubyConfig::numberOfProcessors(); }
-  int getNumMemories() { return RubyConfig::numberOfMemories(); }
-  Profiler* getProfiler() { return m_profiler_ptr; }
-  Driver* getDriver() { assert(m_driver_ptr != NULL); return m_driver_ptr; }
+  static RubyPort* getPortOnly(const string & name) {
+    assert(m_ports.count(name) == 1); return m_ports[name]; }
+  static RubyPort* getPort(const string & name, void (*hit_callback)(int64_t)) {
+    assert(m_ports.count(name) == 1); m_ports[name]->registerHitCallback(hit_callback); return m_ports[name]; }
+  static Network* getNetwork() { assert(m_network_ptr != NULL); return m_network_ptr; }
+  static Topology* getTopology(const string & name) { assert(m_topologies.count(name) == 1); return m_topologies[name]; }
+  static CacheMemory* getCache(const string & name) { assert(m_caches.count(name) == 1); return m_caches[name]; }
+  static DirectoryMemory* getDirectory(const string & name) { assert(m_directories.count(name) == 1); return m_directories[name]; }
+  static MemoryControl* getMemoryControl(const string & name) { assert(m_memorycontrols.count(name) == 1); return m_memorycontrols[name]; }
+  static Sequencer* getSequencer(const string & name) { assert(m_sequencers.count(name) == 1); return m_sequencers[name]; }
+  static DMASequencer* getDMASequencer(const string & name) { assert(m_dma_sequencers.count(name) == 1); return m_dma_sequencers[name]; }
+  static AbstractController* getController(const string & name) { assert(m_controllers.count(name) == 1); return m_controllers[name]; }
+
+  static RubyEventQueue* getEventQueue() { return g_eventQueue_ptr; }
+
+  static int getNumberOfDirectories() { return m_directories.size(); }
+  static int getNumberOfSequencers() { return m_sequencers.size(); }
+
+  Profiler* getProfiler() {assert(m_profiler_ptr != NULL); return m_profiler_ptr; }
   Tracer* getTracer() { assert(m_tracer_ptr != NULL); return m_tracer_ptr; }
-  Network* getNetwork() { assert(m_network_ptr != NULL); return m_network_ptr; }
-  XactIsolationChecker* getXactIsolationChecker() { assert(m_xact_isolation_checker!= NULL); return m_xact_isolation_checker;}
-  XactCommitArbiter* getXactCommitArbiter() { assert(m_xact_commit_arbiter!= NULL); return m_xact_commit_arbiter;}
-  XactVisualizer*    getXactVisualizer() { assert(m_xact_visualizer!= NULL); return m_xact_visualizer;}
-
-  AbstractChip* getChip(int chipNumber) const { assert(m_chip_vector[chipNumber] != NULL); return m_chip_vector[chipNumber];}
-  Sequencer* getSequencer(int procNumber) const {
-    assert(procNumber < RubyConfig::numberOfProcessors());
-    return m_chip_vector[procNumber/RubyConfig::numberOfProcsPerChip()]->getSequencer(procNumber%RubyConfig::numberOfProcsPerChip());
-  }
-  TransactionInterfaceManager* getTransactionInterfaceManager(int procNumber) const {
-    return m_chip_vector[procNumber/RubyConfig::numberOfProcsPerChip()]->getTransactionInterfaceManager(procNumber%RubyConfig::numberOfProcsPerChip());
-  }
+  static MemoryVector* getMemoryVector() { assert(m_mem_vec_ptr != NULL); return m_mem_vec_ptr;}
+
   void recordCacheContents(CacheRecorder& tr) const;
-  void printConfig(ostream& out) const;
-  void printStats(ostream& out);
+  static void printConfig(ostream& out);
+  static void printStats(ostream& out);
   void clearStats() const;
 
+  uint64 getInstructionCount(int thread) { return 1; }
+  static uint64 getCycleCount(int thread) { return g_eventQueue_ptr->getTime(); }
+
   void print(ostream& out) const;
+  /*
 #ifdef CHECK_COHERENCE
   void checkGlobalCoherenceInvariant(const Address& addr);
 #endif
+  */
 
 private:
-  // Private Methods
-  void init();
-  void createDriver();
+  // Constructors
+  RubySystem(const vector <RubyObjConf> & cfg_file);
 
   // Private copy constructor and assignment operator
   RubySystem(const RubySystem& obj);
   RubySystem& operator=(const RubySystem& obj);
 
+  void init(const vector<string> & argv);
+
+  static void printSystemConfig(ostream& out);
+
+private:
+  // configuration parameters
+  static int m_random_seed;
+  static bool m_randomization;
+  static int m_tech_nm;
+  static int m_freq_mhz;
+  static int m_block_size_bytes;
+  static int m_block_size_bits;
+  static uint64 m_memory_size_bytes;
+  static int m_memory_size_bits;
+
   // Data Members (m_ prefix)
-  Network* m_network_ptr;
-  Vector<AbstractChip*> m_chip_vector;
-  Profiler* m_profiler_ptr;
-  bool m_preinitialized_driver;
-  Driver* m_driver_ptr;
-  Tracer* m_tracer_ptr;
-  XactIsolationChecker *m_xact_isolation_checker;
-  XactCommitArbiter    *m_xact_commit_arbiter;
-  XactVisualizer       *m_xact_visualizer;
+  static Network* m_network_ptr;
+  static map< string, Topology* > m_topologies;
+  static map< string, RubyPort* > m_ports;
+  static map< string, CacheMemory* > m_caches;
+  static map< string, DirectoryMemory* > m_directories;
+  static map< string, Sequencer* > m_sequencers;
+  static map< string, DMASequencer* > m_dma_sequencers;
+  static map< string, AbstractController* > m_controllers;
+  static map< string, MemoryControl* > m_memorycontrols;
+
+  //added by SS
+  //static map< string, Tracer* > m_tracers;
+
+  static Profiler* m_profiler_ptr;
+  static Tracer* m_tracer_ptr;
+  static MemoryVector* m_mem_vec_ptr;
 };
 
 // Output operator declaration