1/*
2 * Copyright (c) 2000-2005 The Regents of The University of Michigan
3 * Copyright (c) 2008 The Hewlett-Packard Development Company
4 * Copyright (c) 2013 Advanced Micro Devices, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are
9 * met: redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer;
11 * redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution;
14 * neither the name of the copyright holders nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 *
30 * Authors: Steve Reinhardt
31 * Nathan Binkert
32 * Steve Raasch
33 */
34
35#include <cassert>
36#include <iostream>
37#include <string>
38#include <vector>
39
40#include "base/hashmap.hh"
41#include "base/misc.hh"
42#include "base/trace.hh"
43#include "cpu/smt.hh"
44#include "debug/Config.hh"
45#include "sim/core.hh"
46#include "sim/eventq_impl.hh"
47
48using namespace std;
49
50Tick simQuantum = 0;
51
52//
53// Main Event Queues
54//
55// Events on these queues are processed at the *beginning* of each
56// cycle, before the pipeline simulation is performed.
57//
58uint32_t numMainEventQueues = 0;
59vector<EventQueue *> mainEventQueue;
60__thread EventQueue *_curEventQueue = NULL;
61bool inParallelMode = false;
62
63EventQueue *
64getEventQueue(uint32_t index)
65{
66 while (numMainEventQueues <= index) {
67 numMainEventQueues++;
68 mainEventQueue.push_back(
69 new EventQueue(csprintf("MainEventQueue-%d", index)));
70 }
71
72 return mainEventQueue[index];
73}
74
75#ifndef NDEBUG
76Counter Event::instanceCounter = 0;
77#endif
78
79Event::~Event()
80{
81 assert(!scheduled());
82 flags = 0;
83}
84
85const std::string
86Event::name() const
87{
88#ifndef NDEBUG
89 return csprintf("Event_%d", instance);
90#else
91 return csprintf("Event_%x", (uintptr_t)this);
92#endif
93}
94
95
96Event *
97Event::insertBefore(Event *event, Event *curr)
98{
99 // Either way, event will be the top element in the 'in bin' list
100 // which is the pointer we need in order to look into the list, so
101 // we need to insert that into the bin list.
102 if (!curr || *event < *curr) {
103 // Insert the event before the current list since it is in the future.
104 event->nextBin = curr;
105 event->nextInBin = NULL;
106 } else {
107 // Since we're on the correct list, we need to point to the next list
108 event->nextBin = curr->nextBin; // curr->nextBin can now become stale
109
110 // Insert event at the top of the stack
111 event->nextInBin = curr;
112 }
113
114 return event;
115}
116
117void
118EventQueue::insert(Event *event)
119{
120 // Deal with the head case
121 if (!head || *event <= *head) {
122 head = Event::insertBefore(event, head);
123 return;
124 }
125
126 // Figure out either which 'in bin' list we are on, or where a new list
127 // needs to be inserted
128 Event *prev = head;
129 Event *curr = head->nextBin;
130 while (curr && *curr < *event) {
131 prev = curr;
132 curr = curr->nextBin;
133 }
134
135 // Note: this operation may render all nextBin pointers on the
136 // prev 'in bin' list stale (except for the top one)
137 prev->nextBin = Event::insertBefore(event, curr);
138}
139
140Event *
141Event::removeItem(Event *event, Event *top)
142{
143 Event *curr = top;
144 Event *next = top->nextInBin;
145
146 // if we removed the top item, we need to handle things specially
147 // and just remove the top item, fixing up the next bin pointer of
148 // the new top item
149 if (event == top) {
150 if (!next)
151 return top->nextBin;
152 next->nextBin = top->nextBin;
153 return next;
154 }
155
156 // Since we already checked the current element, we're going to
157 // keep checking event against the next element.
158 while (event != next) {
159 if (!next)
160 panic("event not found!");
161
162 curr = next;
163 next = next->nextInBin;
164 }
165
166 // remove next from the 'in bin' list since it's what we're looking for
167 curr->nextInBin = next->nextInBin;
168 return top;
169}
170
171void
172EventQueue::remove(Event *event)
173{
174 if (head == NULL)
175 panic("event not found!");
176
177 assert(event->queue == this);
178
179 // deal with an event on the head's 'in bin' list (event has the same
180 // time as the head)
181 if (*head == *event) {
182 head = Event::removeItem(event, head);
183 return;
184 }
185
186 // Find the 'in bin' list that this event belongs on
187 Event *prev = head;
188 Event *curr = head->nextBin;
189 while (curr && *curr < *event) {
190 prev = curr;
191 curr = curr->nextBin;
192 }
193
194 if (!curr || *curr != *event)
195 panic("event not found!");
196
197 // curr points to the top item of the the correct 'in bin' list, when
198 // we remove an item, it returns the new top item (which may be
199 // unchanged)
200 prev->nextBin = Event::removeItem(event, curr);
201}
202
203Event *
204EventQueue::serviceOne()
205{
206 std::lock_guard<EventQueue> lock(*this);
207 Event *event = head;
208 Event *next = head->nextInBin;
209 event->flags.clear(Event::Scheduled);
210
211 if (next) {
212 // update the next bin pointer since it could be stale
213 next->nextBin = head->nextBin;
214
215 // pop the stack
216 head = next;
217 } else {
218 // this was the only element on the 'in bin' list, so get rid of
219 // the 'in bin' list and point to the next bin list
220 head = head->nextBin;
221 }
222
223 // handle action
224 if (!event->squashed()) {
225 // forward current cycle to the time when this event occurs.
226 setCurTick(event->when());
227
228 event->process();
229 if (event->isExitEvent()) {
230 assert(!event->flags.isSet(Event::AutoDelete) ||
231 !event->flags.isSet(Event::IsMainQueue)); // would be silly
232 return event;
233 }
234 } else {
235 event->flags.clear(Event::Squashed);
236 }
237
238 if (event->flags.isSet(Event::AutoDelete) && !event->scheduled())
239 delete event;
240
241 return NULL;
242}
243
244void
| 1/*
2 * Copyright (c) 2000-2005 The Regents of The University of Michigan
3 * Copyright (c) 2008 The Hewlett-Packard Development Company
4 * Copyright (c) 2013 Advanced Micro Devices, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions are
9 * met: redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer;
11 * redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution;
14 * neither the name of the copyright holders nor the names of its
15 * contributors may be used to endorse or promote products derived from
16 * this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 *
30 * Authors: Steve Reinhardt
31 * Nathan Binkert
32 * Steve Raasch
33 */
34
35#include <cassert>
36#include <iostream>
37#include <string>
38#include <vector>
39
40#include "base/hashmap.hh"
41#include "base/misc.hh"
42#include "base/trace.hh"
43#include "cpu/smt.hh"
44#include "debug/Config.hh"
45#include "sim/core.hh"
46#include "sim/eventq_impl.hh"
47
48using namespace std;
49
50Tick simQuantum = 0;
51
52//
53// Main Event Queues
54//
55// Events on these queues are processed at the *beginning* of each
56// cycle, before the pipeline simulation is performed.
57//
58uint32_t numMainEventQueues = 0;
59vector<EventQueue *> mainEventQueue;
60__thread EventQueue *_curEventQueue = NULL;
61bool inParallelMode = false;
62
63EventQueue *
64getEventQueue(uint32_t index)
65{
66 while (numMainEventQueues <= index) {
67 numMainEventQueues++;
68 mainEventQueue.push_back(
69 new EventQueue(csprintf("MainEventQueue-%d", index)));
70 }
71
72 return mainEventQueue[index];
73}
74
75#ifndef NDEBUG
76Counter Event::instanceCounter = 0;
77#endif
78
79Event::~Event()
80{
81 assert(!scheduled());
82 flags = 0;
83}
84
85const std::string
86Event::name() const
87{
88#ifndef NDEBUG
89 return csprintf("Event_%d", instance);
90#else
91 return csprintf("Event_%x", (uintptr_t)this);
92#endif
93}
94
95
96Event *
97Event::insertBefore(Event *event, Event *curr)
98{
99 // Either way, event will be the top element in the 'in bin' list
100 // which is the pointer we need in order to look into the list, so
101 // we need to insert that into the bin list.
102 if (!curr || *event < *curr) {
103 // Insert the event before the current list since it is in the future.
104 event->nextBin = curr;
105 event->nextInBin = NULL;
106 } else {
107 // Since we're on the correct list, we need to point to the next list
108 event->nextBin = curr->nextBin; // curr->nextBin can now become stale
109
110 // Insert event at the top of the stack
111 event->nextInBin = curr;
112 }
113
114 return event;
115}
116
117void
118EventQueue::insert(Event *event)
119{
120 // Deal with the head case
121 if (!head || *event <= *head) {
122 head = Event::insertBefore(event, head);
123 return;
124 }
125
126 // Figure out either which 'in bin' list we are on, or where a new list
127 // needs to be inserted
128 Event *prev = head;
129 Event *curr = head->nextBin;
130 while (curr && *curr < *event) {
131 prev = curr;
132 curr = curr->nextBin;
133 }
134
135 // Note: this operation may render all nextBin pointers on the
136 // prev 'in bin' list stale (except for the top one)
137 prev->nextBin = Event::insertBefore(event, curr);
138}
139
140Event *
141Event::removeItem(Event *event, Event *top)
142{
143 Event *curr = top;
144 Event *next = top->nextInBin;
145
146 // if we removed the top item, we need to handle things specially
147 // and just remove the top item, fixing up the next bin pointer of
148 // the new top item
149 if (event == top) {
150 if (!next)
151 return top->nextBin;
152 next->nextBin = top->nextBin;
153 return next;
154 }
155
156 // Since we already checked the current element, we're going to
157 // keep checking event against the next element.
158 while (event != next) {
159 if (!next)
160 panic("event not found!");
161
162 curr = next;
163 next = next->nextInBin;
164 }
165
166 // remove next from the 'in bin' list since it's what we're looking for
167 curr->nextInBin = next->nextInBin;
168 return top;
169}
170
171void
172EventQueue::remove(Event *event)
173{
174 if (head == NULL)
175 panic("event not found!");
176
177 assert(event->queue == this);
178
179 // deal with an event on the head's 'in bin' list (event has the same
180 // time as the head)
181 if (*head == *event) {
182 head = Event::removeItem(event, head);
183 return;
184 }
185
186 // Find the 'in bin' list that this event belongs on
187 Event *prev = head;
188 Event *curr = head->nextBin;
189 while (curr && *curr < *event) {
190 prev = curr;
191 curr = curr->nextBin;
192 }
193
194 if (!curr || *curr != *event)
195 panic("event not found!");
196
197 // curr points to the top item of the the correct 'in bin' list, when
198 // we remove an item, it returns the new top item (which may be
199 // unchanged)
200 prev->nextBin = Event::removeItem(event, curr);
201}
202
203Event *
204EventQueue::serviceOne()
205{
206 std::lock_guard<EventQueue> lock(*this);
207 Event *event = head;
208 Event *next = head->nextInBin;
209 event->flags.clear(Event::Scheduled);
210
211 if (next) {
212 // update the next bin pointer since it could be stale
213 next->nextBin = head->nextBin;
214
215 // pop the stack
216 head = next;
217 } else {
218 // this was the only element on the 'in bin' list, so get rid of
219 // the 'in bin' list and point to the next bin list
220 head = head->nextBin;
221 }
222
223 // handle action
224 if (!event->squashed()) {
225 // forward current cycle to the time when this event occurs.
226 setCurTick(event->when());
227
228 event->process();
229 if (event->isExitEvent()) {
230 assert(!event->flags.isSet(Event::AutoDelete) ||
231 !event->flags.isSet(Event::IsMainQueue)); // would be silly
232 return event;
233 }
234 } else {
235 event->flags.clear(Event::Squashed);
236 }
237
238 if (event->flags.isSet(Event::AutoDelete) && !event->scheduled())
239 delete event;
240
241 return NULL;
242}
243
244void
|
245Event::serialize(std::ostream &os)
| 245Event::serialize(CheckpointOut &cp) const
|
246{
247 SERIALIZE_SCALAR(_when);
248 SERIALIZE_SCALAR(_priority);
249 short _flags = flags;
250 SERIALIZE_SCALAR(_flags);
251}
252
253void
| 246{
247 SERIALIZE_SCALAR(_when);
248 SERIALIZE_SCALAR(_priority);
249 short _flags = flags;
250 SERIALIZE_SCALAR(_flags);
251}
252
253void
|
254Event::unserialize(Checkpoint *cp, const string §ion)
| 254Event::unserialize(CheckpointIn &cp)
|
255{
256}
257
258void
| 255{
256}
257
258void
|
259Event::unserialize(Checkpoint *cp, const string §ion, EventQueue *eventq)
| 259Event::unserializeEvent(CheckpointIn &cp, EventQueue *eventq)
|
260{
261 if (scheduled())
262 eventq->deschedule(this);
263
264 UNSERIALIZE_SCALAR(_when);
265 UNSERIALIZE_SCALAR(_priority);
266
267 short _flags;
268 UNSERIALIZE_SCALAR(_flags);
269
270 // Old checkpoints had no concept of the Initialized flag
271 // so restoring from old checkpoints always fail.
272 // Events are initialized on construction but original code
273 // "flags = _flags" would just overwrite the initialization.
274 // So, read in the checkpoint flags, but then set the Initialized
275 // flag on top of it in order to avoid failures.
276 assert(initialized());
277 flags = _flags;
278 flags.set(Initialized);
279
280 // need to see if original event was in a scheduled, unsquashed
281 // state, but don't want to restore those flags in the current
282 // object itself (since they aren't immediately true)
283 bool wasScheduled = flags.isSet(Scheduled) && !flags.isSet(Squashed);
284 flags.clear(Squashed | Scheduled);
285
286 if (wasScheduled) {
287 DPRINTF(Config, "rescheduling at %d\n", _when);
288 eventq->schedule(this, _when);
289 }
290}
291
292void
| 260{
261 if (scheduled())
262 eventq->deschedule(this);
263
264 UNSERIALIZE_SCALAR(_when);
265 UNSERIALIZE_SCALAR(_priority);
266
267 short _flags;
268 UNSERIALIZE_SCALAR(_flags);
269
270 // Old checkpoints had no concept of the Initialized flag
271 // so restoring from old checkpoints always fail.
272 // Events are initialized on construction but original code
273 // "flags = _flags" would just overwrite the initialization.
274 // So, read in the checkpoint flags, but then set the Initialized
275 // flag on top of it in order to avoid failures.
276 assert(initialized());
277 flags = _flags;
278 flags.set(Initialized);
279
280 // need to see if original event was in a scheduled, unsquashed
281 // state, but don't want to restore those flags in the current
282 // object itself (since they aren't immediately true)
283 bool wasScheduled = flags.isSet(Scheduled) && !flags.isSet(Squashed);
284 flags.clear(Squashed | Scheduled);
285
286 if (wasScheduled) {
287 DPRINTF(Config, "rescheduling at %d\n", _when);
288 eventq->schedule(this, _when);
289 }
290}
291
292void
|
293EventQueue::serialize(ostream &os)
| 293EventQueue::serialize(CheckpointOut &cp) const
|
294{
295 std::list<Event *> eventPtrs;
296
297 int numEvents = 0;
298 Event *nextBin = head;
299 while (nextBin) {
300 Event *nextInBin = nextBin;
301
302 while (nextInBin) {
303 if (nextInBin->flags.isSet(Event::AutoSerialize)) {
304 eventPtrs.push_back(nextInBin);
| 294{
295 std::list<Event *> eventPtrs;
296
297 int numEvents = 0;
298 Event *nextBin = head;
299 while (nextBin) {
300 Event *nextInBin = nextBin;
301
302 while (nextInBin) {
303 if (nextInBin->flags.isSet(Event::AutoSerialize)) {
304 eventPtrs.push_back(nextInBin);
|
305 paramOut(os, csprintf("event%d", numEvents++),
| 305 paramOut(cp, csprintf("event%d", numEvents++),
|
306 nextInBin->name());
307 }
308 nextInBin = nextInBin->nextInBin;
309 }
310
311 nextBin = nextBin->nextBin;
312 }
313
314 SERIALIZE_SCALAR(numEvents);
315
| 306 nextInBin->name());
307 }
308 nextInBin = nextInBin->nextInBin;
309 }
310
311 nextBin = nextBin->nextBin;
312 }
313
314 SERIALIZE_SCALAR(numEvents);
315
|
316 for (std::list<Event *>::iterator it = eventPtrs.begin();
317 it != eventPtrs.end(); ++it) {
318 (*it)->nameOut(os);
319 (*it)->serialize(os);
320 }
| 316 for (Event *ev : eventPtrs)
317 ev->serializeSection(cp, ev->name());
|
321}
322
323void
| 318}
319
320void
|
324EventQueue::unserialize(Checkpoint *cp, const std::string §ion)
| 321EventQueue::unserialize(CheckpointIn &cp)
|
325{
326 int numEvents;
327 UNSERIALIZE_SCALAR(numEvents);
328
329 std::string eventName;
330 for (int i = 0; i < numEvents; i++) {
331 // get the pointer value associated with the event
| 322{
323 int numEvents;
324 UNSERIALIZE_SCALAR(numEvents);
325
326 std::string eventName;
327 for (int i = 0; i < numEvents; i++) {
328 // get the pointer value associated with the event
|
332 paramIn(cp, section, csprintf("event%d", i), eventName);
| 329 paramIn(cp, csprintf("event%d", i), eventName);
|
333
334 // create the event based on its pointer value
335 Serializable::create(cp, eventName);
336 }
337}
338
339void
340EventQueue::dump() const
341{
342 cprintf("============================================================\n");
343 cprintf("EventQueue Dump (cycle %d)\n", curTick());
344 cprintf("------------------------------------------------------------\n");
345
346 if (empty())
347 cprintf("<No Events>\n");
348 else {
349 Event *nextBin = head;
350 while (nextBin) {
351 Event *nextInBin = nextBin;
352 while (nextInBin) {
353 nextInBin->dump();
354 nextInBin = nextInBin->nextInBin;
355 }
356
357 nextBin = nextBin->nextBin;
358 }
359 }
360
361 cprintf("============================================================\n");
362}
363
364bool
365EventQueue::debugVerify() const
366{
367 m5::hash_map<long, bool> map;
368
369 Tick time = 0;
370 short priority = 0;
371
372 Event *nextBin = head;
373 while (nextBin) {
374 Event *nextInBin = nextBin;
375 while (nextInBin) {
376 if (nextInBin->when() < time) {
377 cprintf("time goes backwards!");
378 nextInBin->dump();
379 return false;
380 } else if (nextInBin->when() == time &&
381 nextInBin->priority() < priority) {
382 cprintf("priority inverted!");
383 nextInBin->dump();
384 return false;
385 }
386
387 if (map[reinterpret_cast<long>(nextInBin)]) {
388 cprintf("Node already seen");
389 nextInBin->dump();
390 return false;
391 }
392 map[reinterpret_cast<long>(nextInBin)] = true;
393
394 time = nextInBin->when();
395 priority = nextInBin->priority();
396
397 nextInBin = nextInBin->nextInBin;
398 }
399
400 nextBin = nextBin->nextBin;
401 }
402
403 return true;
404}
405
406Event*
407EventQueue::replaceHead(Event* s)
408{
409 Event* t = head;
410 head = s;
411 return t;
412}
413
414void
415dumpMainQueue()
416{
417 for (uint32_t i = 0; i < numMainEventQueues; ++i) {
418 mainEventQueue[i]->dump();
419 }
420}
421
422
423const char *
424Event::description() const
425{
426 return "generic";
427}
428
429void
430Event::trace(const char *action)
431{
432 // This DPRINTF is unconditional because calls to this function
433 // are protected by an 'if (DTRACE(Event))' in the inlined Event
434 // methods.
435 //
436 // This is just a default implementation for derived classes where
437 // it's not worth doing anything special. If you want to put a
438 // more informative message in the trace, override this method on
439 // the particular subclass where you have the information that
440 // needs to be printed.
441 DPRINTFN("%s event %s @ %d\n", description(), action, when());
442}
443
444void
445Event::dump() const
446{
447 cprintf("Event %s (%s)\n", name(), description());
448 cprintf("Flags: %#x\n", flags);
449#ifdef EVENTQ_DEBUG
450 cprintf("Created: %d\n", whenCreated);
451#endif
452 if (scheduled()) {
453#ifdef EVENTQ_DEBUG
454 cprintf("Scheduled at %d\n", whenScheduled);
455#endif
456 cprintf("Scheduled for %d, priority %d\n", when(), _priority);
457 } else {
458 cprintf("Not Scheduled\n");
459 }
460}
461
462EventQueue::EventQueue(const string &n)
463 : objName(n), head(NULL), _curTick(0)
464{
465}
466
467void
468EventQueue::asyncInsert(Event *event)
469{
470 async_queue_mutex.lock();
471 async_queue.push_back(event);
472 async_queue_mutex.unlock();
473}
474
475void
476EventQueue::handleAsyncInsertions()
477{
478 assert(this == curEventQueue());
479 async_queue_mutex.lock();
480
481 while (!async_queue.empty()) {
482 insert(async_queue.front());
483 async_queue.pop_front();
484 }
485
486 async_queue_mutex.unlock();
487}
| 330
331 // create the event based on its pointer value
332 Serializable::create(cp, eventName);
333 }
334}
335
336void
337EventQueue::dump() const
338{
339 cprintf("============================================================\n");
340 cprintf("EventQueue Dump (cycle %d)\n", curTick());
341 cprintf("------------------------------------------------------------\n");
342
343 if (empty())
344 cprintf("<No Events>\n");
345 else {
346 Event *nextBin = head;
347 while (nextBin) {
348 Event *nextInBin = nextBin;
349 while (nextInBin) {
350 nextInBin->dump();
351 nextInBin = nextInBin->nextInBin;
352 }
353
354 nextBin = nextBin->nextBin;
355 }
356 }
357
358 cprintf("============================================================\n");
359}
360
361bool
362EventQueue::debugVerify() const
363{
364 m5::hash_map<long, bool> map;
365
366 Tick time = 0;
367 short priority = 0;
368
369 Event *nextBin = head;
370 while (nextBin) {
371 Event *nextInBin = nextBin;
372 while (nextInBin) {
373 if (nextInBin->when() < time) {
374 cprintf("time goes backwards!");
375 nextInBin->dump();
376 return false;
377 } else if (nextInBin->when() == time &&
378 nextInBin->priority() < priority) {
379 cprintf("priority inverted!");
380 nextInBin->dump();
381 return false;
382 }
383
384 if (map[reinterpret_cast<long>(nextInBin)]) {
385 cprintf("Node already seen");
386 nextInBin->dump();
387 return false;
388 }
389 map[reinterpret_cast<long>(nextInBin)] = true;
390
391 time = nextInBin->when();
392 priority = nextInBin->priority();
393
394 nextInBin = nextInBin->nextInBin;
395 }
396
397 nextBin = nextBin->nextBin;
398 }
399
400 return true;
401}
402
403Event*
404EventQueue::replaceHead(Event* s)
405{
406 Event* t = head;
407 head = s;
408 return t;
409}
410
411void
412dumpMainQueue()
413{
414 for (uint32_t i = 0; i < numMainEventQueues; ++i) {
415 mainEventQueue[i]->dump();
416 }
417}
418
419
420const char *
421Event::description() const
422{
423 return "generic";
424}
425
426void
427Event::trace(const char *action)
428{
429 // This DPRINTF is unconditional because calls to this function
430 // are protected by an 'if (DTRACE(Event))' in the inlined Event
431 // methods.
432 //
433 // This is just a default implementation for derived classes where
434 // it's not worth doing anything special. If you want to put a
435 // more informative message in the trace, override this method on
436 // the particular subclass where you have the information that
437 // needs to be printed.
438 DPRINTFN("%s event %s @ %d\n", description(), action, when());
439}
440
441void
442Event::dump() const
443{
444 cprintf("Event %s (%s)\n", name(), description());
445 cprintf("Flags: %#x\n", flags);
446#ifdef EVENTQ_DEBUG
447 cprintf("Created: %d\n", whenCreated);
448#endif
449 if (scheduled()) {
450#ifdef EVENTQ_DEBUG
451 cprintf("Scheduled at %d\n", whenScheduled);
452#endif
453 cprintf("Scheduled for %d, priority %d\n", when(), _priority);
454 } else {
455 cprintf("Not Scheduled\n");
456 }
457}
458
459EventQueue::EventQueue(const string &n)
460 : objName(n), head(NULL), _curTick(0)
461{
462}
463
464void
465EventQueue::asyncInsert(Event *event)
466{
467 async_queue_mutex.lock();
468 async_queue.push_back(event);
469 async_queue_mutex.unlock();
470}
471
472void
473EventQueue::handleAsyncInsertions()
474{
475 assert(this == curEventQueue());
476 async_queue_mutex.lock();
477
478 while (!async_queue.empty()) {
479 insert(async_queue.front());
480 async_queue.pop_front();
481 }
482
483 async_queue_mutex.unlock();
484}
|