sim_object.hh revision 7532
1/* 2 * Copyright (c) 2001-2005 The Regents of The University of Michigan 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 * Authors: Steve Reinhardt 29 * Nathan Binkert 30 */ 31 32/* @file 33 * User Console Definitions 34 */ 35 36#ifndef __SIM_OBJECT_HH__ 37#define __SIM_OBJECT_HH__ 38 39#include <iostream> 40#include <list> 41#include <map> 42#include <string> 43#include <vector> 44 45#include "params/SimObject.hh" 46#include "sim/eventq.hh" 47#include "sim/serialize.hh" 48 49class BaseCPU; 50class Event; 51 52/* 53 * Abstract superclass for simulation objects. Represents things that 54 * correspond to physical components and can be specified via the 55 * config file (CPUs, caches, etc.). 56 */ 57class SimObject : public EventManager, public Serializable 58{ 59 public: 60 enum State { 61 Running, 62 Draining, 63 Drained 64 }; 65 66 private: 67 State state; 68 69 protected: 70 void changeState(State new_state) { state = new_state; } 71 72 public: 73 State getState() { return state; } 74 75 private: 76 typedef std::vector<SimObject *> SimObjectList; 77 78 // list of all instantiated simulation objects 79 static SimObjectList simObjectList; 80 81 protected: 82 const SimObjectParams *_params; 83 84 public: 85 typedef SimObjectParams Params; 86 const Params *params() const { return _params; } 87 SimObject(const Params *_params); 88 virtual ~SimObject() {} 89 90 public: 91 92 virtual const std::string name() const { return params()->name; } 93 94 // The following SimObject initialization methods are called from 95 // the instantiate() method in src/python/m5/simulate.py. See 96 // that function for details on how/when these methods are 97 // invoked. 98 99 /** 100 * init() is called after all C++ SimObjects have been created and 101 * all ports are connected. Initializations that are independent 102 * of unserialization but rely on a fully instantiated and 103 * connected SimObject graph should be done here. 104 */ 105 virtual void init(); 106 107 /** 108 * loadState() is called on each SimObject when restoring from a 109 * checkpoint. The default implementation simply calls 110 * unserialize() if there is a corresponding section in the 111 * checkpoint. However, objects can override loadState() to get 112 * other behaviors, e.g., doing other programmed initializations 113 * after unserialize(), or complaining if no checkpoint section is 114 * found. 115 */ 116 virtual void loadState(Checkpoint *cp); 117 118 /** 119 * initState() is called on each SimObject when *not* restoring 120 * from a checkpoint. This provides a hook for state 121 * initializations that are only required for a "cold start". 122 */ 123 virtual void initState(); 124 125 // register statistics for this object 126 virtual void regStats(); 127 virtual void regFormulas(); 128 virtual void resetStats(); 129 130 /** 131 * startup() is the final initialization call before simulation. 132 * All state is initialized (including unserialized state, if any, 133 * such as the curTick value), so this is the appropriate place to 134 * schedule initial event(s) for objects that need them. 135 */ 136 virtual void startup(); 137 138 // static: call nameOut() & serialize() on all SimObjects 139 static void serializeAll(std::ostream &); 140 static void unserializeAll(Checkpoint *cp); 141 142 // Methods to drain objects in order to take checkpoints 143 // Or switch from timing -> atomic memory model 144 // Drain returns 0 if the simobject can drain immediately or 145 // the number of times the drain_event's process function will be called 146 // before the object will be done draining. Normally this should be 1 147 virtual unsigned int drain(Event *drain_event); 148 virtual void resume(); 149 virtual void setMemoryMode(State new_mode); 150 virtual void switchOut(); 151 virtual void takeOverFrom(BaseCPU *cpu); 152 153#ifdef DEBUG 154 public: 155 bool doDebugBreak; 156 static void debugObjectBreak(const std::string &objs); 157#endif 158 159 /** 160 * Find the SimObject with the given name and return a pointer to 161 * it. Primarily used for interactive debugging. Argument is 162 * char* rather than std::string to make it callable from gdb. 163 */ 164 static SimObject *find(const char *name); 165}; 166 167#endif // __SIM_OBJECT_HH__ 168