src/mem/ruby/system/System.hh

   1
   2 /*
   3  * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions are
   8  * met: redistributions of source code must retain the above copyright
   9  * notice, this list of conditions and the following disclaimer;
  10  * redistributions in binary form must reproduce the above copyright
  11  * notice, this list of conditions and the following disclaimer in the
  12  * documentation and/or other materials provided with the distribution;
  13  * neither the name of the copyright holders nor the names of its
  14  * contributors may be used to endorse or promote products derived from
  15  * this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 /*
  31  * System.hh
  32  *
  33  * Description: Contains all of the various parts of the system we are
  34  * simulating.  Performs allocation, deallocation, and setup of all
  35  * the major components of the system
  36  *
  37  * $Id$
  38  *
  39  */
  40
  41 #ifndef SYSTEM_H
  42 #define SYSTEM_H
  43
  44 #include "mem/ruby/system/RubyPort.hh"
  45 #include "mem/ruby/common/Global.hh"
  46 #include "mem/gems_common/Vector.hh"
  47 #include "mem/ruby/eventqueue/RubyEventQueue.hh"
  48 #include <map>
  49
  50 class Profiler;
  51 class Network;
  52 class CacheRecorder;
  53 class Tracer;
  54 class Sequencer;
  55 class DMASequencer;
  56 class MemoryVector;
  57 class AbstractController;
  58 class MessageBuffer;
  59 class CacheMemory;
  60 class DirectoryMemory;
  61 class Topology;
  62 class MemoryControl;
  63
  64 struct RubyObjConf {
  65   string type;
  66   string name;
  67   vector<string> argv;
  68   RubyObjConf(string _type, string _name, vector<string> _argv)
  69     : type(_type), name(_name), argv(_argv)
  70   {}
  71 };
  72
  73 class RubySystem {
  74 public:
  75   static RubySystem* create(const vector <RubyObjConf> & sys_conf);
  76   // Destructor
  77   ~RubySystem();
  78
  79   // config accessors
  80   static int getRandomSeed() { return m_random_seed; }
  81   static int getRandomization() { return m_randomization; }
  82   static int getTechNm() { return m_tech_nm; }
  83   static int getFreqMhz() { return m_freq_mhz; }
  84   static int getBlockSizeBytes() { return m_block_size_bytes; }
  85   static int getBlockSizeBits() { return m_block_size_bits; }
  86   static uint64 getMemorySizeBytes() { return m_memory_size_bytes; }
  87   static int getMemorySizeBits() { return m_memory_size_bits; }
  88
  89   // Public Methods
  90   static RubyPort* getPortOnly(const string & name) {
  91     assert(m_ports.count(name) == 1); return m_ports[name]; }
  92   static RubyPort* getPort(const string & name, void (*hit_callback)(int64_t)) {
  93     assert(m_ports.count(name) == 1); m_ports[name]->registerHitCallback(hit_callback); return m_ports[name]; }
  94   static Network* getNetwork() { assert(m_network_ptr != NULL); return m_network_ptr; }
  95   static Topology* getTopology(const string & name) { assert(m_topologies.count(name) == 1); return m_topologies[name]; }
  96   static CacheMemory* getCache(const string & name) { assert(m_caches.count(name) == 1); return m_caches[name]; }
  97   static DirectoryMemory* getDirectory(const string & name) { assert(m_directories.count(name) == 1); return m_directories[name]; }
  98   static MemoryControl* getMemoryControl(const string & name) { assert(m_memorycontrols.count(name) == 1); return m_memorycontrols[name]; }
  99   static Sequencer* getSequencer(const string & name) { assert(m_sequencers.count(name) == 1); return m_sequencers[name]; }
 100   static DMASequencer* getDMASequencer(const string & name) { assert(m_dma_sequencers.count(name) == 1); return m_dma_sequencers[name]; }
 101   static AbstractController* getController(const string & name) { assert(m_controllers.count(name) == 1); return m_controllers[name]; }
 102
 103   static RubyEventQueue* getEventQueue() { return g_eventQueue_ptr; }
 104
 105   static int getNumberOfDirectories() { return m_directories.size(); }
 106   static int getNumberOfSequencers() { return m_sequencers.size(); }
 107
 108   Profiler* getProfiler() {assert(m_profiler_ptr != NULL); return m_profiler_ptr; }
 109   Tracer* getTracer() { assert(m_tracer_ptr != NULL); return m_tracer_ptr; }
 110   static MemoryVector* getMemoryVector() { assert(m_mem_vec_ptr != NULL); return m_mem_vec_ptr;}
 111
 112   void recordCacheContents(CacheRecorder& tr) const;
 113   static void printConfig(ostream& out);
 114   static void printStats(ostream& out);
 115   void clearStats() const;
 116
 117   uint64 getInstructionCount(int thread) { return 1; }
 118   static uint64 getCycleCount(int thread) { return g_eventQueue_ptr->getTime(); }
 119
 120   void print(ostream& out) const;
 121   /*
 122 #ifdef CHECK_COHERENCE
 123   void checkGlobalCoherenceInvariant(const Address& addr);
 124 #endif
 125   */
 126
 127 private:
 128   // Constructors
 129   RubySystem(const vector <RubyObjConf> & cfg_file);
 130
 131   // Private copy constructor and assignment operator
 132   RubySystem(const RubySystem& obj);
 133   RubySystem& operator=(const RubySystem& obj);
 134
 135   void init(const vector<string> & argv);
 136
 137   static void printSystemConfig(ostream& out);
 138
 139 private:
 140   // configuration parameters
 141   static int m_random_seed;
 142   static bool m_randomization;
 143   static int m_tech_nm;
 144   static int m_freq_mhz;
 145   static int m_block_size_bytes;
 146   static int m_block_size_bits;
 147   static uint64 m_memory_size_bytes;
 148   static int m_memory_size_bits;
 149
 150   // Data Members (m_ prefix)
 151   static Network* m_network_ptr;
 152   static map< string, Topology* > m_topologies;
 153   static map< string, RubyPort* > m_ports;
 154   static map< string, CacheMemory* > m_caches;
 155   static map< string, DirectoryMemory* > m_directories;
 156   static map< string, Sequencer* > m_sequencers;
 157   static map< string, DMASequencer* > m_dma_sequencers;
 158   static map< string, AbstractController* > m_controllers;
 159   static map< string, MemoryControl* > m_memorycontrols;
 160
 161   //added by SS
 162   //static map< string, Tracer* > m_tracers;
 163
 164   static Profiler* m_profiler_ptr;
 165   static Tracer* m_tracer_ptr;
 166   static MemoryVector* m_mem_vec_ptr;
 167 };
 168
 169 // Output operator declaration
 170 ostream& operator<<(ostream& out, const RubySystem& obj);
 171
 172 // ******************* Definitions *******************
 173
 174 // Output operator definition
 175 inline
 176 ostream& operator<<(ostream& out, const RubySystem& obj)
 177 {
 178 //  obj.print(out);
 179   out << flush;
 180   return out;
 181 }
 182
 183 #endif //SYSTEM_H
 184
 185
 186