RubySystem.hh revision 10525
1/* 2 * Copyright (c) 1999-2012 Mark D. Hill and David A. Wood 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are 7 * met: redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer; 9 * redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution; 12 * neither the name of the copyright holders nor the names of its 13 * contributors may be used to endorse or promote products derived from 14 * this software without specific prior written permission. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29/* 30 * Contains all of the various parts of the system we are simulating. 31 * Performs allocation, deallocation, and setup of all the major 32 * components of the system 33 */ 34 35#ifndef __MEM_RUBY_SYSTEM_SYSTEM_HH__ 36#define __MEM_RUBY_SYSTEM_SYSTEM_HH__ 37 38#include "base/callback.hh" 39#include "base/output.hh" 40#include "mem/ruby/profiler/Profiler.hh" 41#include "mem/ruby/slicc_interface/AbstractController.hh" 42#include "mem/ruby/system/CacheRecorder.hh" 43#include "mem/packet.hh" 44#include "params/RubySystem.hh" 45#include "sim/clocked_object.hh" 46 47class Network; 48 49class RubySystem : public ClockedObject 50{ 51 public: 52 class RubyEvent : public Event 53 { 54 public: 55 RubyEvent(RubySystem* _ruby_system) 56 { 57 ruby_system = _ruby_system; 58 } 59 private: 60 void process(); 61 62 RubySystem* ruby_system; 63 }; 64 65 friend class RubyEvent; 66 67 typedef RubySystemParams Params; 68 RubySystem(const Params *p); 69 ~RubySystem(); 70 71 // config accessors 72 static int getRandomSeed() { return m_random_seed; } 73 static int getRandomization() { return m_randomization; } 74 static uint32_t getBlockSizeBytes() { return m_block_size_bytes; } 75 static uint32_t getBlockSizeBits() { return m_block_size_bits; } 76 static uint32_t getMemorySizeBits() { return m_memory_size_bits; } 77 78 SimpleMemory *getPhysMem() { return m_phys_mem; } 79 80 // Public Methods 81 Profiler* 82 getProfiler() 83 { 84 assert(m_profiler != NULL); 85 return m_profiler; 86 } 87 88 void regStats() { m_profiler->regStats(name()); } 89 void collateStats() { m_profiler->collateStats(); } 90 void resetStats(); 91 92 void serialize(std::ostream &os); 93 void unserialize(Checkpoint *cp, const std::string §ion); 94 void process(); 95 void startup(); 96 bool functionalRead(Packet *ptr); 97 bool functionalWrite(Packet *ptr); 98 99 void registerNetwork(Network*); 100 void registerAbstractController(AbstractController*); 101 102 bool eventQueueEmpty() { return eventq->empty(); } 103 void enqueueRubyEvent(Tick tick) 104 { 105 RubyEvent* e = new RubyEvent(this); 106 schedule(e, tick); 107 } 108 109 private: 110 // Private copy constructor and assignment operator 111 RubySystem(const RubySystem& obj); 112 RubySystem& operator=(const RubySystem& obj); 113 114 void readCompressedTrace(std::string filename, 115 uint8_t *&raw_data, 116 uint64& uncompressed_trace_size); 117 void writeCompressedTrace(uint8_t *raw_data, std::string file, 118 uint64 uncompressed_trace_size); 119 120 private: 121 // configuration parameters 122 static int m_random_seed; 123 static bool m_randomization; 124 static uint32_t m_block_size_bytes; 125 static uint32_t m_block_size_bits; 126 static uint32_t m_memory_size_bits; 127 SimpleMemory *m_phys_mem; 128 129 Network* m_network; 130 std::vector<AbstractController *> m_abs_cntrl_vec; 131 132 public: 133 Profiler* m_profiler; 134 bool m_warmup_enabled; 135 bool m_cooldown_enabled; 136 CacheRecorder* m_cache_recorder; 137}; 138 139class RubyStatsCallback : public Callback 140{ 141 private: 142 RubySystem *ruby_system; 143 144 public: 145 virtual ~RubyStatsCallback() {} 146 RubyStatsCallback(RubySystem *system) : ruby_system(system) {} 147 void process() { ruby_system->collateStats(); } 148}; 149 150#endif // __MEM_RUBY_SYSTEM_SYSTEM_HH__ 151