/*
+ * Copyright (c) 2013 ARM Limited
+ * All rights reserved
+ *
+ * The license below extends only to copyright in the software and shall
+ * not be construed as granting a license to any other intellectual
+ * property including but not limited to intellectual property relating
+ * to a hardware implementation of the functionality of the software
+ * licensed hereunder. You may use the software subject to the license
+ * terms below provided that you ensure that this notice is replicated
+ * unmodified and in its entirety in all distributions of the software,
+ * modified or unmodified, in source code or in binary form.
+ *
* Copyright (c) 2002-2005 The Regents of The University of Michigan
+ * Copyright (c) 2013 Advanced Micro Devices, Inc.
+ * Copyright (c) 2013 Mark D. Hill and David A. Wood
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Nathan Binkert
*/
#ifndef __SIM_SIM_EVENTS_HH__
#define __SIM_SIM_EVENTS_HH__
-#include "sim/eventq.hh"
+#include "sim/global_event.hh"
+#include "sim/serialize.hh"
//
// Event to terminate simulation at a particular cycle/instruction
//
-class SimExitEvent : public Event
+class GlobalSimLoopExitEvent : public GlobalEvent
{
- private:
+ protected:
// string explaining why we're terminating
std::string cause;
int code;
+ Tick repeat;
public:
- SimExitEvent(const std::string &_cause, int c = 0)
- : Event(&mainEventQueue, Sim_Exit_Pri), cause(_cause),
- code(c)
- { schedule(curTick); }
-
- SimExitEvent(Tick _when, const std::string &_cause, int c = 0)
- : Event(&mainEventQueue, Sim_Exit_Pri), cause(_cause),
- code(c)
- { schedule(_when); }
+ // non-scheduling version for createForUnserialize()
+ GlobalSimLoopExitEvent();
+ GlobalSimLoopExitEvent(Tick when, const std::string &_cause, int c,
+ Tick repeat = 0, bool serialize = false);
- SimExitEvent(EventQueue *q, const std::string &_cause, int c = 0)
- : Event(q, Sim_Exit_Pri), cause(_cause), code(c)
- { schedule(curTick); }
+ const std::string getCause() const { return cause; }
+ const int getCode() const { return code; }
- SimExitEvent(EventQueue *q, Tick _when, const std::string &_cause,
- int c = 0)
- : Event(q, Sim_Exit_Pri), cause(_cause), code(c)
- { schedule(_when); }
+ void process(); // process event
- void process(); // process event
-
- virtual const char *description();
+ virtual const char *description() const;
};
-//
-// Event class to terminate simulation after 'n' related events have
-// occurred using a shared counter: used to terminate when *all*
-// threads have reached a particular instruction count
-//
-class CountedExitEvent : public Event
+class LocalSimLoopExitEvent : public Event
{
- private:
- std::string cause; // string explaining why we're terminating
- int &downCounter; // decrement & terminate if zero
+ protected:
+ // string explaining why we're terminating
+ std::string cause;
+ int code;
+ Tick repeat;
public:
- CountedExitEvent(EventQueue *q, const std::string &_cause,
- Tick _when, int &_downCounter);
+ LocalSimLoopExitEvent();
+ LocalSimLoopExitEvent(const std::string &_cause, int c, Tick repeat = 0,
+ bool serialize = false);
+
+ const std::string getCause() const { return cause; }
+ const int getCode() const { return code; }
- void process(); // process event
+ void process(); // process event
- virtual const char *description();
+ virtual const char *description() const;
+
+ virtual void serialize(std::ostream &os);
+ virtual void unserialize(Checkpoint *cp, const std::string §ion);
+ virtual void unserialize(Checkpoint *cp, const std::string §ion,
+ EventQueue *eventq);
+ static Serializable *createForUnserialize(Checkpoint *cp,
+ const std::string §ion);
};
-//
-// Event to check swap usage
-//
-class CheckSwapEvent : public Event
+class CountedDrainEvent : public Event
{
private:
- int interval;
+ // Count of how many objects have not yet drained
+ int count;
public:
- CheckSwapEvent(EventQueue *q, int ival)
- : Event(q), interval(ival)
- { schedule(curTick + interval); }
+ CountedDrainEvent();
+
+ void process();
- void process(); // process event
+ void setCount(int _count) { count = _count; }
- virtual const char *description();
+ const int getCount() const { return count; }
};
//
-// Progress event: print out cycle every so often so we know we're
-// making forward progress.
+// Event class to terminate simulation after 'n' related events have
+// occurred using a shared counter: used to terminate when *all*
+// threads have reached a particular instruction count
//
-class ProgressEvent : public Event
+class CountedExitEvent : public Event
{
- protected:
- Tick interval;
+ private:
+ std::string cause; // string explaining why we're terminating
+ int &downCounter; // decrement & terminate if zero
public:
- ProgressEvent(EventQueue *q, Tick ival)
- : Event(q), interval(ival)
- { schedule(curTick + interval); }
+ CountedExitEvent(const std::string &_cause, int &_downCounter);
- void process(); // process event
+ void process(); // process event
- virtual const char *description();
+ virtual const char *description() const;
};
+
#endif // __SIM_SIM_EVENTS_HH__