RubySystem.hh revision 6285 
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
50class Profiler;
51class Network;
52class CacheRecorder;
53class Tracer;
54class Sequencer;
55class DMASequencer;
56class MemoryVector;
57class AbstractController;
58class MessageBuffer;
59class CacheMemory;
60class DirectoryMemory;
61class Topology;
62class MemoryControl;
63
64struct 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
73class RubySystem {
74public:
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
127private:
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
139private:
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
170ostream& operator<<(ostream& out, const RubySystem& obj);
171
172// ******************* Definitions *******************
173
174// Output operator definition
175inline
176ostream& 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
187