eventq.hh revision 512
1/* 2 * Copyright (c) 2003 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 29/* @file 30 * EventQueue interfaces 31 */ 32 33#ifndef __EVENTQ_HH__ 34#define __EVENTQ_HH__ 35 36#include <assert.h> 37 38#include <algorithm> 39#include <map> 40#include <string> 41#include <vector> 42 43#include "sim/host.hh" // for Tick 44 45#include "base/fast_alloc.hh" 46#include "sim/serialize.hh" 47#include "base/trace.hh" 48 49class EventQueue; // forward declaration 50 51/* 52 * An item on an event queue. The action caused by a given 53 * event is specified by deriving a subclass and overriding the 54 * process() member function. 55 */ 56class Event : public Serializable, public FastAlloc 57{ 58 friend class EventQueue; 59 60 private: 61 /// queue to which this event belongs (though it may or may not be 62 /// scheduled on this queue yet) 63 EventQueue *queue; 64 65 Event *next; 66 67 Tick _when; //!< timestamp when event should be processed 68 int _priority; //!< event priority 69 char _flags; 70 71 protected: 72 enum Flags { 73 None = 0x0, 74 Squashed = 0x1, 75 Scheduled = 0x2, 76 AutoDelete = 0x4, 77 AutoSerialize = 0x8 78 }; 79 80 bool getFlags(Flags f) const { return (_flags & f) == f; } 81 void setFlags(Flags f) { _flags |= f; } 82 void clearFlags(Flags f) { _flags &= ~f; } 83 84 protected: 85 EventQueue *theQueue() const { return queue; } 86 87#if TRACING_ON 88 Tick when_created; //!< Keep track of creation time For debugging 89 Tick when_scheduled; //!< Keep track of creation time For debugging 90 91 virtual void trace(const char *action); //!< trace event activity 92#else 93 void trace(const char *) {} 94#endif 95 96 unsigned annotated_value; 97 98 public: 99 100 /// Event priorities, to provide tie-breakers for events scheduled 101 /// at the same cycle. Most events are scheduled at the default 102 /// priority; these values are used to control events that need to 103 /// be ordered within a cycle. 104 enum Priority { 105 /// Breakpoints should happen before anything else, so we 106 /// don't miss any action when debugging. 107 Debug_Break_Pri = -100, 108 109 /// For some reason "delayed" inter-cluster writebacks are 110 /// scheduled before regular writebacks (which have default 111 /// priority). Steve? 112 Delayed_Writeback_Pri = -1, 113 114 /// Default is zero for historical reasons. 115 Default_Pri = 0, 116 117 /// CPU switches schedule the new CPU's tick event for the 118 /// same cycle (after unscheduling the old CPU's tick event). 119 /// The switch needs to come before any tick events to make 120 /// sure we don't tick both CPUs in the same cycle. 121 CPU_Switch_Pri = 31, 122 123 /// Serailization needs to occur before tick events also, so 124 /// that a serialize/unserialize is identical to an on-line 125 /// CPU switch. 126 Serialize_Pri = 32, 127 128 /// CPU ticks must come after other associated CPU events 129 /// (such as writebacks). 130 CPU_Tick_Pri = 50, 131 132 /// Statistics events (dump, reset, etc.) come after 133 /// everything else, but before exit. 134 Stat_Event_Pri = 90, 135 136 /// If we want to exit on this cycle, it's the very last thing 137 /// we do. 138 Sim_Exit_Pri = 100 139 }; 140 141 /* 142 * Event constructor 143 * @param queue that the event gets scheduled on 144 */ 145 Event(EventQueue *q, Priority p = Default_Pri) 146 : queue(q), next(NULL), _priority(p), _flags(None), 147#if TRACING_ON 148 when_created(curTick), when_scheduled(0), 149#endif 150 annotated_value(0) 151 { 152 } 153 154 ~Event() {} 155 156 virtual const std::string name() const { 157 return csprintf("Event_%x", (uintptr_t)this); 158 } 159 160 /// Determine if the current event is scheduled 161 bool scheduled() const { return getFlags(Scheduled); } 162 163 /// Schedule the event with the current priority or default priority 164 void schedule(Tick t); 165 166 /// Reschedule the event with the current priority 167 void reschedule(Tick t); 168 169 /// Remove the event from the current schedule 170 void deschedule(); 171 172 /// Return a C string describing the event. This string should 173 /// *not* be dynamically allocated; just a const char array 174 /// describing the event class. 175 virtual const char *description(); 176 177 /// Dump the current event data 178 void dump(); 179 180 /* 181 * This member function is invoked when the event is processed 182 * (occurs). There is no default implementation; each subclass 183 * must provide its own implementation. The event is not 184 * automatically deleted after it is processed (to allow for 185 * statically allocated event objects). 186 * 187 * If the AutoDestroy flag is set, the object is deleted once it 188 * is processed. 189 */ 190 virtual void process() = 0; 191 192 void annotate(unsigned value) { annotated_value = value; }; 193 unsigned annotation() { return annotated_value; } 194 195 /// Squash the current event 196 void squash() { setFlags(Squashed); } 197 198 /// Check whether the event is squashed 199 bool squashed() { return getFlags(Squashed); } 200 201 /// Get the time that the event is scheduled 202 Tick when() const { return _when; } 203 204 /// Get the event priority 205 int priority() const { return _priority; } 206 207 struct priority_compare : 208 public std::binary_function<Event *, Event *, bool> 209 { 210 bool operator()(const Event *l, const Event *r) const { 211 return l->when() >= r->when() || l->priority() >= r->priority(); 212 } 213 }; 214 215 virtual void serialize(std::ostream &os); 216 virtual void unserialize(Checkpoint *cp, const std::string §ion); 217}; 218 219template <class T, void (T::* F)()> 220void 221DelayFunction(Tick when, T *object) 222{ 223 class DelayEvent : public Event 224 { 225 private: 226 T *object; 227 228 public: 229 DelayEvent(Tick when, T *o) 230 : Event(&mainEventQueue), object(o) 231 { setFlags(AutoDestroy); schedule(when); } 232 void process() { (object->*F)(); } 233 const char *description() { return "delay"; } 234 }; 235 236 new DelayEvent(when, object); 237} 238 239/* 240 * Queue of events sorted in time order 241 */ 242class EventQueue : public Serializable 243{ 244 protected: 245 std::string objName; 246 247 private: 248 Event *head; 249 250 void insert(Event *event); 251 void remove(Event *event); 252 253 public: 254 255 // constructor 256 EventQueue(const std::string &n) 257 : objName(n), head(NULL) 258 {} 259 260 virtual const std::string name() const { return objName; } 261 262 // schedule the given event on this queue 263 void schedule(Event *ev); 264 void deschedule(Event *ev); 265 void reschedule(Event *ev); 266 267 Tick nextTick() { return head->when(); } 268 void serviceOne(); 269 270 // process all events up to the given timestamp. we inline a 271 // quick test to see if there are any events to process; if so, 272 // call the internal out-of-line version to process them all. 273 void serviceEvents(Tick when) { 274 while (!empty()) { 275 if (nextTick() > when) 276 break; 277 278 assert(head->when() >= when && "event scheduled in the past"); 279 serviceOne(); 280 } 281 } 282 283 // default: process all events up to 'now' (curTick) 284 void serviceEvents() { serviceEvents(curTick); } 285 286 // return true if no events are queued 287 bool empty() { return head == NULL; } 288 289 void dump(); 290 291 Tick nextEventTime() { return empty() ? curTick : head->when(); } 292 293 virtual void serialize(std::ostream &os); 294 virtual void unserialize(Checkpoint *cp, const std::string §ion); 295}; 296 297 298////////////////////// 299// 300// inline functions 301// 302// can't put these inside declaration due to circular dependence 303// between Event and EventQueue classes. 304// 305////////////////////// 306 307// schedule at specified time (place on event queue specified via 308// constructor) 309inline void 310Event::schedule(Tick t) 311{ 312 assert(!scheduled()); 313 setFlags(Scheduled); 314#if TRACING_ON 315 when_scheduled = curTick; 316#endif 317 _when = t; 318 queue->schedule(this); 319} 320 321inline void 322Event::deschedule() 323{ 324 assert(scheduled()); 325 326 clearFlags(Squashed); 327 clearFlags(Scheduled); 328 queue->deschedule(this); 329} 330 331inline void 332Event::reschedule(Tick t) 333{ 334 assert(scheduled()); 335 clearFlags(Squashed); 336 337#if TRACING_ON 338 when_scheduled = curTick; 339#endif 340 _when = t; 341 queue->reschedule(this); 342} 343 344inline void 345EventQueue::schedule(Event *event) 346{ 347 insert(event); 348 if (DTRACE(Event)) 349 event->trace("scheduled"); 350} 351 352inline void 353EventQueue::deschedule(Event *event) 354{ 355 remove(event); 356 if (DTRACE(Event)) 357 event->trace("descheduled"); 358} 359 360inline void 361EventQueue::reschedule(Event *event) 362{ 363 remove(event); 364 insert(event); 365 if (DTRACE(Event)) 366 event->trace("rescheduled"); 367} 368 369 370////////////////////// 371// 372// Main Event Queue 373// 374// Events on this queue are processed at the *beginning* of each 375// cycle, before the pipeline simulation is performed. 376// 377// defined in eventq.cc 378// 379////////////////////// 380extern EventQueue mainEventQueue; 381 382#endif // __EVENTQ_HH__ 383