X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fsim%2Fsim_object.hh;h=9bf95d07f473dd76f2c0ea3ec22bcbb67fd045c3;hb=da0c770943a26cd258fcd9bf608e1c78ff8e6be5;hp=1640be404c44b6c5877ab67e64210061e12c4fd5;hpb=d4a6d9846a2c55861a93e78ba4b6d82d14bed9c6;p=gem5.git diff --git a/src/sim/sim_object.hh b/src/sim/sim_object.hh index 1640be404..9bf95d07f 100644 --- a/src/sim/sim_object.hh +++ b/src/sim/sim_object.hh @@ -45,12 +45,13 @@ #include "enums/MemoryMode.hh" #include "params/SimObject.hh" -#include "sim/eventq.hh" +#include "sim/drain.hh" +#include "sim/eventq_impl.hh" #include "sim/serialize.hh" class BaseCPU; class Event; - +class ProbeManager; /** * Abstract superclass for simulation objects. Represents things that * correspond to physical components and can be specified via the @@ -72,40 +73,7 @@ class Event; * *
  • SimObject::resetStats() *
  • SimObject::startup() - *
  • SimObject::resume() if resuming from a checkpoint. - * - * - * An object's internal state needs to be drained when creating a - * checkpoint, switching between CPU models, or switching between - * timing models. Once the internal state has been drained from - * all objects in the system, the objects are serialized to - * disc or the configuration change takes place. The process works as - * follows (see simulate.py for details): - * - *
      - *
    1. An instance of a CountedDrainEvent is created to keep track of - * how many objects need to be drained. The object maintains an - * internal counter that is decreased every time its - * CountedDrainEvent::process() method is called. When the counter - * reaches zero, the simulation is stopped. - * - *
    2. Call SimObject::drain() for every object in the - * system. Draining has completed if all of them return - * zero. Otherwise, the sum of the return values is loaded into - * the counter of the CountedDrainEvent. A pointer of the drain - * event is passed as an argument to the drain() method. - * - *
    3. Continue simulation. When an object has finished draining its - * internal state, it calls CountedDrainEvent::process() on the - * CountedDrainEvent. When counter in the CountedDrainEvent reaches - * zero, the simulation stops. - * - *
    4. Check if any object still needs draining, if so repeat the - * process above. - * - *
    5. Serialize objects, switch CPU model, or change timing model. - * - *
    6. Call SimObject::resume() and continue the simulation. + *
    7. Drainable::drainResume() if resuming from a checkpoint. *
    * * @note Whenever a method is called on all objects in the simulator's @@ -114,48 +82,17 @@ class Event; * SimObject.py). This has the effect of calling the method on the * parent node before its children. */ -class SimObject : public EventManager, public Serializable +class SimObject : public EventManager, public Serializable, public Drainable { - public: - /** - * Object drain/handover states - * - * An object starts out in the Running state. When the simulator - * prepares to take a snapshot or prepares a CPU for handover, it - * calls the drain() method to transfer the object into the - * Draining or Drained state. If any object enters the Draining - * state (drain() returning >0), simulation continues until it all - * objects have entered the Drained. - * - * The before resuming simulation, the simulator calls resume() to - * transfer the object to the Running state. - * - * \note Even though the state of an object (visible to the rest - * of the world through getState()) could be used to determine if - * all objects have entered the Drained state, the protocol is - * actually a bit more elaborate. See drain() for details. - */ - enum State { - Running, /** Running normally */ - Draining, /** Draining buffers pending serialization/handover */ - Drained /** Buffers drained, ready for serialization/handover */ - }; - - private: - State state; - - protected: - void changeState(State new_state) { state = new_state; } - - public: - State getState() { return state; } - private: typedef std::vector SimObjectList; /** List of all instantiated simulation objects. */ static SimObjectList simObjectList; + /** Manager coordinates hooking up probe points with listeners. */ + ProbeManager *probeManager; + protected: /** Cached copy of the object parameters. */ const SimObjectParams *_params; @@ -164,7 +101,7 @@ class SimObject : public EventManager, public Serializable typedef SimObjectParams Params; const Params *params() const { return _params; } SimObject(const Params *_params); - virtual ~SimObject() {} + virtual ~SimObject(); public: @@ -209,81 +146,39 @@ class SimObject : public EventManager, public Serializable virtual void resetStats(); /** - * startup() is the final initialization call before simulation. - * All state is initialized (including unserialized state, if any, - * such as the curTick() value), so this is the appropriate place to - * schedule initial event(s) for objects that need them. - */ - virtual void startup(); - - /** - * Serialize all SimObjects in the system. + * Register probe points for this object. */ - static void serializeAll(std::ostream &os); + virtual void regProbePoints(); /** - * Determine if an object needs draining and register a drain - * event. - * - * When draining the state of an object, the simulator calls drain - * with a pointer to a drain event. If the object does not need - * further simulation to drain internal buffers, it switched to - * the Drained state and returns 0, otherwise it switches to the - * Draining state and returns the number of times that it will - * call Event::process() on the drain event. Most objects are - * expected to return either 0 or 1. - * - * The default implementation simply switches to the Drained state - * and returns 0. - * - * @note An object that has entered the Drained state can be - * disturbed by other objects in the system and consequently be - * forced to enter the Draining state again. The simulator - * therefore repeats the draining process until all objects return - * 0 on the first call to drain(). - * - * @param drain_event Event to use to inform the simulator when - * the draining has completed. - * - * @return 0 if the object is ready for serialization now, >0 if - * it needs further simulation. + * Register probe listeners for this object. */ - virtual unsigned int drain(Event *drain_event); + virtual void regProbeListeners(); /** - * Switch an object in the Drained stated into the Running state. + * Get the probe manager for this object. */ - virtual void resume(); + ProbeManager *getProbeManager(); /** - * Change the memory mode the simulator operates in. - * - * @note Should only be implemented in the System object. + * startup() is the final initialization call before simulation. + * All state is initialized (including unserialized state, if any, + * such as the curTick() value), so this is the appropriate place to + * schedule initial event(s) for objects that need them. */ - virtual void setMemoryMode(Enums::MemoryMode new_mode); + virtual void startup(); /** - * Prepare a CPU model to be switched out, invoked on active CPUs - * that are about to be replaced. - * - * @note This should only be implemented in CPU models. + * Provide a default implementation of the drain interface that + * simply returns 0 (draining completed) and sets the drain state + * to Drained. */ - virtual void switchOut(); + unsigned int drain(DrainManager *drainManger); /** - * Load the state of a CPU from the previous CPU object, invoked - * on all new CPUs that are about to be switched in. - * - * A CPU model implementing this method is expected to initialize - * its state from the old CPU and connect its memory (unless they - * are already connected) to the memories connected to the old - * CPU. - * - * @note This should only be implemented in CPU models. - * - * @param cpu CPU to initialize read state from. + * Serialize all SimObjects in the system. */ - virtual void takeOverFrom(BaseCPU *cpu); + static void serializeAll(std::ostream &os); #ifdef DEBUG public: @@ -299,4 +194,8 @@ class SimObject : public EventManager, public Serializable static SimObject *find(const char *name); }; +#ifdef DEBUG +void debugObjectBreak(const char *objs); +#endif + #endif // __SIM_OBJECT_HH__