summaryrefslogtreecommitdiff
path: root/src/sim/eventq.hh
diff options
context:
space:
mode:
Diffstat (limited to 'src/sim/eventq.hh')
-rw-r--r--src/sim/eventq.hh101
1 files changed, 71 insertions, 30 deletions
diff --git a/src/sim/eventq.hh b/src/sim/eventq.hh
index 5c98659b6..a29942d07 100644
--- a/src/sim/eventq.hh
+++ b/src/sim/eventq.hh
@@ -44,6 +44,7 @@
#include <vector>
#include "base/fast_alloc.hh"
+#include "base/flags.hh"
#include "base/misc.hh"
#include "base/trace.hh"
#include "sim/serialize.hh"
@@ -64,6 +65,19 @@ class Event : public Serializable, public FastAlloc
{
friend class EventQueue;
+ protected:
+ typedef short FlagsType;
+ typedef ::Flags<FlagsType> Flags;
+
+ static const FlagsType PublicRead = 0x003f;
+ static const FlagsType PublicWrite = 0x001d;
+ static const FlagsType Squashed = 0x0001;
+ static const FlagsType Scheduled = 0x0002;
+ static const FlagsType AutoDelete = 0x0004;
+ static const FlagsType AutoSerialize = 0x0008;
+ static const FlagsType IsExitEvent = 0x0010;
+ static const FlagsType IsMainQueue = 0x0020;
+
private:
// The event queue is now a linked list of linked lists. The
// 'nextBin' pointer is to find the bin, where a bin is defined as
@@ -82,7 +96,7 @@ class Event : public Serializable, public FastAlloc
Tick _when; //!< timestamp when event should be processed
short _priority; //!< event priority
- short _flags;
+ Flags flags;
#ifndef NDEBUG
/// Global counter to generate unique IDs for Event instances
@@ -117,21 +131,48 @@ class Event : public Serializable, public FastAlloc
}
protected:
- enum Flags {
- None = 0x0,
- Squashed = 0x1,
- Scheduled = 0x2,
- AutoDelete = 0x4,
- AutoSerialize = 0x8,
- IsExitEvent = 0x10,
- IsMainQueue = 0x20
- };
+ /// Accessor for flags.
+ Flags
+ getFlags() const
+ {
+ return flags & PublicRead;
+ }
+
+ Flags
+ getFlags(Flags _flags) const
+ {
+ assert(flags.noneSet(~PublicRead));
+ return flags.isSet(_flags);
+ }
- bool getFlags(Flags f) const { return (_flags & f) == f; }
- void setFlags(Flags f) { _flags |= f; }
- void clearFlags(Flags f) { _flags &= ~f; }
+ Flags
+ allFlags(Flags _flags) const
+ {
+ assert(_flags.noneSet(~PublicRead));
+ return flags.allSet(_flags);
+ }
+
+ /// Accessor for flags.
+ void
+ setFlags(Flags _flags)
+ {
+ assert(_flags.noneSet(~PublicWrite));
+ flags.set(_flags);
+ }
+
+ void
+ clearFlags(Flags _flags)
+ {
+ assert(_flags.noneSet(~PublicWrite));
+ flags.clear(_flags);
+ }
+
+ void
+ clearFlags()
+ {
+ flags.clear(PublicWrite);
+ }
- protected:
// This function isn't really useful if TRACING_ON is not defined
virtual void trace(const char *action); //!< trace event activity
@@ -197,7 +238,7 @@ class Event : public Serializable, public FastAlloc
* @param queue that the event gets scheduled on
*/
Event(Priority p = Default_Pri)
- : nextBin(NULL), nextInBin(NULL), _priority(p), _flags(None)
+ : nextBin(NULL), nextInBin(NULL), _priority(p)
{
#ifndef NDEBUG
instance = ++instanceCounter;
@@ -234,16 +275,16 @@ class Event : public Serializable, public FastAlloc
virtual void process() = 0;
/// Determine if the current event is scheduled
- bool scheduled() const { return getFlags(Scheduled); }
+ bool scheduled() const { return flags.isSet(Scheduled); }
/// Squash the current event
- void squash() { setFlags(Squashed); }
+ void squash() { flags.set(Squashed); }
/// Check whether the event is squashed
- bool squashed() const { return getFlags(Squashed); }
+ bool squashed() const { return flags.isSet(Squashed); }
/// See if this is a SimExitEvent (without resorting to RTTI)
- bool isExitEvent() const { return getFlags(IsExitEvent); }
+ bool isExitEvent() const { return flags.isSet(IsExitEvent); }
/// Get the time that the event is scheduled
Tick when() const { return _when; }
@@ -398,7 +439,7 @@ DelayFunction(EventQueue *eventq, Tick when, T *object)
public:
DelayEvent(T *o)
: object(o)
- { setFlags(this->AutoDestroy); }
+ { this->setFlags(AutoDelete); }
void process() { (object->*F)(); }
const char *description() const { return "delay"; }
};
@@ -431,11 +472,11 @@ EventQueue::schedule(Event *event, Tick when)
event->setWhen(when, this);
insert(event);
- event->setFlags(Event::Scheduled);
+ event->flags.set(Event::Scheduled);
if (this == &mainEventQueue)
- event->setFlags(Event::IsMainQueue);
+ event->flags.set(Event::IsMainQueue);
else
- event->clearFlags(Event::IsMainQueue);
+ event->flags.clear(Event::IsMainQueue);
if (DTRACE(Event))
event->trace("scheduled");
@@ -448,10 +489,10 @@ EventQueue::deschedule(Event *event)
remove(event);
- event->clearFlags(Event::Squashed);
- event->clearFlags(Event::Scheduled);
+ event->flags.clear(Event::Squashed);
+ event->flags.clear(Event::Scheduled);
- if (event->getFlags(Event::AutoDelete))
+ if (event->flags.isSet(Event::AutoDelete))
delete event;
if (DTRACE(Event))
@@ -469,12 +510,12 @@ EventQueue::reschedule(Event *event, Tick when, bool always)
event->setWhen(when, this);
insert(event);
- event->clearFlags(Event::Squashed);
- event->setFlags(Event::Scheduled);
+ event->flags.clear(Event::Squashed);
+ event->flags.set(Event::Scheduled);
if (this == &mainEventQueue)
- event->setFlags(Event::IsMainQueue);
+ event->flags.set(Event::IsMainQueue);
else
- event->clearFlags(Event::IsMainQueue);
+ event->flags.clear(Event::IsMainQueue);
if (DTRACE(Event))
event->trace("rescheduled");