eventq.hh (7005:3d5c4acb6015) eventq.hh (7058:5c7416199efd)
1/*
2 * Copyright (c) 2000-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;

--- 66 unchanged lines hidden (view full) ---

75 static const FlagsType AutoDelete = 0x0004;
76 static const FlagsType AutoSerialize = 0x0008;
77 static const FlagsType IsExitEvent = 0x0010;
78 static const FlagsType IsMainQueue = 0x0020;
79#ifdef EVENTQ_DEBUG
80 static const FlagsType Initialized = 0xf000;
81#endif
82
1/*
2 * Copyright (c) 2000-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;

--- 66 unchanged lines hidden (view full) ---

75 static const FlagsType AutoDelete = 0x0004;
76 static const FlagsType AutoSerialize = 0x0008;
77 static const FlagsType IsExitEvent = 0x0010;
78 static const FlagsType IsMainQueue = 0x0020;
79#ifdef EVENTQ_DEBUG
80 static const FlagsType Initialized = 0xf000;
81#endif
82
83 public:
84 typedef int8_t Priority;
85
83 private:
84 // The event queue is now a linked list of linked lists. The
85 // 'nextBin' pointer is to find the bin, where a bin is defined as
86 // when+priority. All events in the same bin will be stored in a
87 // second linked list (a stack) maintained by the 'nextInBin'
88 // pointer. The list will be accessed in LIFO order. The end
89 // result is that the insert/removal in 'nextBin' is
90 // linear/constant, and the lookup/removal in 'nextInBin' is
91 // constant/constant. Hopefully this is a significant improvement
92 // over the current fully linear insertion.
93 Event *nextBin;
94 Event *nextInBin;
95
96 static Event *insertBefore(Event *event, Event *curr);
97 static Event *removeItem(Event *event, Event *last);
98
99 Tick _when; //!< timestamp when event should be processed
86 private:
87 // The event queue is now a linked list of linked lists. The
88 // 'nextBin' pointer is to find the bin, where a bin is defined as
89 // when+priority. All events in the same bin will be stored in a
90 // second linked list (a stack) maintained by the 'nextInBin'
91 // pointer. The list will be accessed in LIFO order. The end
92 // result is that the insert/removal in 'nextBin' is
93 // linear/constant, and the lookup/removal in 'nextInBin' is
94 // constant/constant. Hopefully this is a significant improvement
95 // over the current fully linear insertion.
96 Event *nextBin;
97 Event *nextInBin;
98
99 static Event *insertBefore(Event *event, Event *curr);
100 static Event *removeItem(Event *event, Event *last);
101
102 Tick _when; //!< timestamp when event should be processed
100 short _priority; //!< event priority
103 Priority _priority; //!< event priority
101 Flags flags;
102
103#ifndef NDEBUG
104 /// Global counter to generate unique IDs for Event instances
105 static Counter instanceCounter;
106
107 /// This event's unique ID. We can also use pointer values for
108 /// this but they're not consistent across runs making debugging

--- 69 unchanged lines hidden (view full) ---

178 // This function isn't really useful if TRACING_ON is not defined
179 virtual void trace(const char *action); //!< trace event activity
180
181 public:
182 /// Event priorities, to provide tie-breakers for events scheduled
183 /// at the same cycle. Most events are scheduled at the default
184 /// priority; these values are used to control events that need to
185 /// be ordered within a cycle.
104 Flags flags;
105
106#ifndef NDEBUG
107 /// Global counter to generate unique IDs for Event instances
108 static Counter instanceCounter;
109
110 /// This event's unique ID. We can also use pointer values for
111 /// this but they're not consistent across runs making debugging

--- 69 unchanged lines hidden (view full) ---

181 // This function isn't really useful if TRACING_ON is not defined
182 virtual void trace(const char *action); //!< trace event activity
183
184 public:
185 /// Event priorities, to provide tie-breakers for events scheduled
186 /// at the same cycle. Most events are scheduled at the default
187 /// priority; these values are used to control events that need to
188 /// be ordered within a cycle.
186 enum Priority {
187 /// Minimum priority
188 Minimum_Pri = SHRT_MIN,
189
189
190 /// If we enable tracing on a particular cycle, do that as the
191 /// very first thing so we don't miss any of the events on
192 /// that cycle (even if we enter the debugger).
193 Trace_Enable_Pri = -101,
190 /// Minimum priority
191 static const Priority Minimum_Pri = SCHAR_MIN;
194
192
195 /// Breakpoints should happen before anything else (except
196 /// enabling trace output), so we don't miss any action when
197 /// debugging.
198 Debug_Break_Pri = -100,
193 /// If we enable tracing on a particular cycle, do that as the
194 /// very first thing so we don't miss any of the events on
195 /// that cycle (even if we enter the debugger).
196 static const Priority Trace_Enable_Pri = -101;
199
197
200 /// CPU switches schedule the new CPU's tick event for the
201 /// same cycle (after unscheduling the old CPU's tick event).
202 /// The switch needs to come before any tick events to make
203 /// sure we don't tick both CPUs in the same cycle.
204 CPU_Switch_Pri = -31,
198 /// Breakpoints should happen before anything else (except
199 /// enabling trace output), so we don't miss any action when
200 /// debugging.
201 static const Priority Debug_Break_Pri = -100;
205
202
206 /// For some reason "delayed" inter-cluster writebacks are
207 /// scheduled before regular writebacks (which have default
208 /// priority). Steve?
209 Delayed_Writeback_Pri = -1,
203 /// CPU switches schedule the new CPU's tick event for the
204 /// same cycle (after unscheduling the old CPU's tick event).
205 /// The switch needs to come before any tick events to make
206 /// sure we don't tick both CPUs in the same cycle.
207 static const Priority CPU_Switch_Pri = -31;
210
208
211 /// Default is zero for historical reasons.
212 Default_Pri = 0,
209 /// For some reason "delayed" inter-cluster writebacks are
210 /// scheduled before regular writebacks (which have default
211 /// priority). Steve?
212 static const Priority Delayed_Writeback_Pri = -1;
213
213
214 /// Serailization needs to occur before tick events also, so
215 /// that a serialize/unserialize is identical to an on-line
216 /// CPU switch.
217 Serialize_Pri = 32,
214 /// Default is zero for historical reasons.
215 static const Priority Default_Pri = 0;
218
216
219 /// CPU ticks must come after other associated CPU events
220 /// (such as writebacks).
221 CPU_Tick_Pri = 50,
217 /// Serailization needs to occur before tick events also, so
218 /// that a serialize/unserialize is identical to an on-line
219 /// CPU switch.
220 static const Priority Serialize_Pri = 32;
222
221
223 /// Statistics events (dump, reset, etc.) come after
224 /// everything else, but before exit.
225 Stat_Event_Pri = 90,
222 /// CPU ticks must come after other associated CPU events
223 /// (such as writebacks).
224 static const Priority CPU_Tick_Pri = 50;
226
225
227 /// Progress events come at the end.
228 Progress_Event_Pri = 95,
226 /// Statistics events (dump, reset, etc.) come after
227 /// everything else, but before exit.
228 static const Priority Stat_Event_Pri = 90;
229
229
230 /// If we want to exit on this cycle, it's the very last thing
231 /// we do.
232 Sim_Exit_Pri = 100,
230 /// Progress events come at the end.
231 static const Priority Progress_Event_Pri = 95;
233
232
234 /// Maximum priority
235 Maximum_Pri = SHRT_MAX
236 };
233 /// If we want to exit on this cycle, it's the very last thing
234 /// we do.
235 static const Priority Sim_Exit_Pri = 100;
237
236
237 /// Maximum priority
238 static const Priority Maximum_Pri = SCHAR_MAX;
239
238 /*
239 * Event constructor
240 * @param queue that the event gets scheduled on
241 */
242 Event(Priority p = Default_Pri)
243 : nextBin(NULL), nextInBin(NULL), _priority(p)
244 {
245#ifndef NDEBUG

--- 42 unchanged lines hidden (view full) ---

288
289 /// See if this is a SimExitEvent (without resorting to RTTI)
290 bool isExitEvent() const { return flags.isSet(IsExitEvent); }
291
292 /// Get the time that the event is scheduled
293 Tick when() const { return _when; }
294
295 /// Get the event priority
240 /*
241 * Event constructor
242 * @param queue that the event gets scheduled on
243 */
244 Event(Priority p = Default_Pri)
245 : nextBin(NULL), nextInBin(NULL), _priority(p)
246 {
247#ifndef NDEBUG

--- 42 unchanged lines hidden (view full) ---

290
291 /// See if this is a SimExitEvent (without resorting to RTTI)
292 bool isExitEvent() const { return flags.isSet(IsExitEvent); }
293
294 /// Get the time that the event is scheduled
295 Tick when() const { return _when; }
296
297 /// Get the event priority
296 int priority() const { return _priority; }
298 Priority priority() const { return _priority; }
297
298#ifndef SWIG
299 struct priority_compare
300 : public std::binary_function<Event *, Event *, bool>
301 {
302 bool
303 operator()(const Event *l, const Event *r) const
304 {

--- 282 unchanged lines hidden --- 		299
300#ifndef SWIG
301 struct priority_compare
302 : public std::binary_function<Event *, Event *, bool>
303 {
304 bool
305 operator()(const Event *l, const Event *r) const
306 {

--- 282 unchanged lines hidden ---