1/*
2 * Copyright 2018 Google, Inc.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met: redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer;
8 * redistributions in binary form must reproduce the above copyright
9 * notice, this list of conditions and the following disclaimer in the
10 * documentation and/or other materials provided with the distribution;
11 * neither the name of the copyright holders nor the names of its
12 * contributors may be used to endorse or promote products derived from
13 * this software without specific prior written permission.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
19 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
21 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 *
27 * Authors: Gabe Black
28 */
29
30#ifndef __SYSTEMC_CORE_SCHEDULER_HH__
31#define __SYSTEMC_CORE_SCHEDULER_HH__
32
33#include <functional>
34#include <map>
35#include <set>
36#include <vector>
37
38#include "base/logging.hh"
39#include "sim/core.hh"
40#include "sim/eventq.hh"
41#include "systemc/core/channel.hh"
42#include "systemc/core/list.hh"
43#include "systemc/core/process.hh"
44#include "systemc/core/sched_event.hh"
45
46class Fiber;
47
48namespace sc_gem5
49{
50
51typedef NodeList<Process> ProcessList;
52typedef NodeList<Channel> ChannelList;
53
54/*
55 * The scheduler supports three different mechanisms, the initialization phase,
56 * delta cycles, and timed notifications.
57 *
58 * INITIALIZATION PHASE
59 *
60 * The initialization phase has three parts:
61 * 1. Run requested channel updates.
62 * 2. Make processes which need to initialize runnable (methods and threads
63 * which didn't have dont_initialize called on them).
64 * 3. Process delta notifications.
65 *
66 * First, the Kernel SimObject calls the update() method during its startup()
67 * callback which handles the requested channel updates. The Kernel also
68 * schedules an event to be run at time 0 with a slightly elevated priority
69 * so that it happens before any "normal" event.
70 *
71 * When that t0 event happens, it calls the schedulers prepareForInit method
72 * which performs step 2 above. That indirectly causes the scheduler's
73 * readyEvent to be scheduled with slightly lowered priority, ensuring it
74 * happens after any "normal" event.
75 *
76 * Because delta notifications are scheduled at the standard priority, all
77 * of those events will happen next, performing step 3 above. Once they finish,
78 * if the readyEvent was scheduled above, there shouldn't be any higher
79 * priority events in front of it. When it runs, it will start the first
80 * evaluate phase of the first delta cycle.
81 *
82 * DELTA CYCLE
83 *
84 * A delta cycle has three phases within it.
85 * 1. The evaluate phase where runnable processes are allowed to run.
86 * 2. The update phase where requested channel updates hapen.
87 * 3. The delta notification phase where delta notifications happen.
88 *
89 * The readyEvent runs all three steps of the delta cycle. It first goes
90 * through the list of runnable processes and executes them until the set is
91 * empty, and then immediately runs the update phase. Since these are all part
92 * of the same event, there's no chance for other events to intervene and
93 * break the required order above.
94 *
95 * During the update phase above, the spec forbids any action which would make
96 * a process runnable. That means that once the update phase finishes, the set
97 * of runnable processes will be empty. There may, however, have been some
98 * delta notifications/timeouts which will have been scheduled during either
99 * the evaluate or update phase above. Those will have been accumulated in the
100 * scheduler, and are now all executed.
101 *
102 * If any processes became runnable during the delta notification phase, the
103 * readyEvent will have been scheduled and will be waiting and ready to run
104 * again, effectively starting the next delta cycle.
105 *
106 * TIMED NOTIFICATION PHASE
107 *
108 * If no processes became runnable, the event queue will continue to process
109 * events until it comes across an event which represents all the timed
110 * notifications which are supposed to happen at a particular time. The object
111 * which tracks them will execute all those notifications, and then destroy
112 * itself. If the readyEvent is now ready to run, the next delta cycle will
113 * start.
114 *
115 * PAUSE/STOP
116 *
117 * To inject a pause from sc_pause which should happen after the current delta
118 * cycle's delta notification phase, an event is scheduled with a lower than
119 * normal priority, but higher than the readyEvent. That ensures that any
120 * delta notifications which are scheduled with normal priority will happen
121 * first, since those are part of the current delta cycle. Then the pause
122 * event will happen before the next readyEvent which would start the next
123 * delta cycle. All of these events are scheduled for the current time, and so
124 * would happen before any timed notifications went off.
125 *
126 * To inject a stop from sc_stop, the delta cycles should stop before even the
127 * delta notifications have happened, but after the evaluate and update phases.
128 * For that, a stop event with slightly higher than normal priority will be
129 * scheduled so that it happens before any of the delta notification events
130 * which are at normal priority.
131 *
132 * MAX RUN TIME
133 *
134 * When sc_start is called, it's possible to pass in a maximum time the
135 * simulation should run to, at which point sc_pause is implicitly called. The
136 * simulation is supposed to run up to the latest timed notification phase
137 * which is less than or equal to the maximum time. In other words it should
138 * run timed notifications at the maximum time, but not the subsequent evaluate
139 * phase. That's implemented by scheduling an event at the max time with a
140 * priority which is lower than all the others except the ready event. Timed
141 * notifications will happen before it fires, but it will override any ready
142 * event and prevent the evaluate phase from starting.
143 */
144
145class Scheduler
146{
147 public:
| 1/*
2 * Copyright 2018 Google, Inc.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions are
6 * met: redistributions of source code must retain the above copyright
7 * notice, this list of conditions and the following disclaimer;
8 * redistributions in binary form must reproduce the above copyright
9 * notice, this list of conditions and the following disclaimer in the
10 * documentation and/or other materials provided with the distribution;
11 * neither the name of the copyright holders nor the names of its
12 * contributors may be used to endorse or promote products derived from
13 * this software without specific prior written permission.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
19 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
21 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 *
27 * Authors: Gabe Black
28 */
29
30#ifndef __SYSTEMC_CORE_SCHEDULER_HH__
31#define __SYSTEMC_CORE_SCHEDULER_HH__
32
33#include <functional>
34#include <map>
35#include <set>
36#include <vector>
37
38#include "base/logging.hh"
39#include "sim/core.hh"
40#include "sim/eventq.hh"
41#include "systemc/core/channel.hh"
42#include "systemc/core/list.hh"
43#include "systemc/core/process.hh"
44#include "systemc/core/sched_event.hh"
45
46class Fiber;
47
48namespace sc_gem5
49{
50
51typedef NodeList<Process> ProcessList;
52typedef NodeList<Channel> ChannelList;
53
54/*
55 * The scheduler supports three different mechanisms, the initialization phase,
56 * delta cycles, and timed notifications.
57 *
58 * INITIALIZATION PHASE
59 *
60 * The initialization phase has three parts:
61 * 1. Run requested channel updates.
62 * 2. Make processes which need to initialize runnable (methods and threads
63 * which didn't have dont_initialize called on them).
64 * 3. Process delta notifications.
65 *
66 * First, the Kernel SimObject calls the update() method during its startup()
67 * callback which handles the requested channel updates. The Kernel also
68 * schedules an event to be run at time 0 with a slightly elevated priority
69 * so that it happens before any "normal" event.
70 *
71 * When that t0 event happens, it calls the schedulers prepareForInit method
72 * which performs step 2 above. That indirectly causes the scheduler's
73 * readyEvent to be scheduled with slightly lowered priority, ensuring it
74 * happens after any "normal" event.
75 *
76 * Because delta notifications are scheduled at the standard priority, all
77 * of those events will happen next, performing step 3 above. Once they finish,
78 * if the readyEvent was scheduled above, there shouldn't be any higher
79 * priority events in front of it. When it runs, it will start the first
80 * evaluate phase of the first delta cycle.
81 *
82 * DELTA CYCLE
83 *
84 * A delta cycle has three phases within it.
85 * 1. The evaluate phase where runnable processes are allowed to run.
86 * 2. The update phase where requested channel updates hapen.
87 * 3. The delta notification phase where delta notifications happen.
88 *
89 * The readyEvent runs all three steps of the delta cycle. It first goes
90 * through the list of runnable processes and executes them until the set is
91 * empty, and then immediately runs the update phase. Since these are all part
92 * of the same event, there's no chance for other events to intervene and
93 * break the required order above.
94 *
95 * During the update phase above, the spec forbids any action which would make
96 * a process runnable. That means that once the update phase finishes, the set
97 * of runnable processes will be empty. There may, however, have been some
98 * delta notifications/timeouts which will have been scheduled during either
99 * the evaluate or update phase above. Those will have been accumulated in the
100 * scheduler, and are now all executed.
101 *
102 * If any processes became runnable during the delta notification phase, the
103 * readyEvent will have been scheduled and will be waiting and ready to run
104 * again, effectively starting the next delta cycle.
105 *
106 * TIMED NOTIFICATION PHASE
107 *
108 * If no processes became runnable, the event queue will continue to process
109 * events until it comes across an event which represents all the timed
110 * notifications which are supposed to happen at a particular time. The object
111 * which tracks them will execute all those notifications, and then destroy
112 * itself. If the readyEvent is now ready to run, the next delta cycle will
113 * start.
114 *
115 * PAUSE/STOP
116 *
117 * To inject a pause from sc_pause which should happen after the current delta
118 * cycle's delta notification phase, an event is scheduled with a lower than
119 * normal priority, but higher than the readyEvent. That ensures that any
120 * delta notifications which are scheduled with normal priority will happen
121 * first, since those are part of the current delta cycle. Then the pause
122 * event will happen before the next readyEvent which would start the next
123 * delta cycle. All of these events are scheduled for the current time, and so
124 * would happen before any timed notifications went off.
125 *
126 * To inject a stop from sc_stop, the delta cycles should stop before even the
127 * delta notifications have happened, but after the evaluate and update phases.
128 * For that, a stop event with slightly higher than normal priority will be
129 * scheduled so that it happens before any of the delta notification events
130 * which are at normal priority.
131 *
132 * MAX RUN TIME
133 *
134 * When sc_start is called, it's possible to pass in a maximum time the
135 * simulation should run to, at which point sc_pause is implicitly called. The
136 * simulation is supposed to run up to the latest timed notification phase
137 * which is less than or equal to the maximum time. In other words it should
138 * run timed notifications at the maximum time, but not the subsequent evaluate
139 * phase. That's implemented by scheduling an event at the max time with a
140 * priority which is lower than all the others except the ready event. Timed
141 * notifications will happen before it fires, but it will override any ready
142 * event and prevent the evaluate phase from starting.
143 */
144
145class Scheduler
146{
147 public:
|
148 typedef std::set<ScEvent *> ScEvents;
| 148 typedef std::list<ScEvent *> ScEvents;
|
149
150 class TimeSlot : public ::Event
151 {
152 public:
153 TimeSlot() : ::Event(Default_Pri, AutoDelete) {}
154
155 ScEvents events;
156 void process();
157 };
158
159 typedef std::map<Tick, TimeSlot *> TimeSlots;
160
161 Scheduler();
162 ~Scheduler();
163
164 void clear();
165
166 const std::string name() const { return "systemc_scheduler"; }
167
168 uint64_t numCycles() { return _numCycles; }
169 Process *current() { return _current; }
170
171 void initPhase();
172
173 // Register a process with the scheduler.
174 void reg(Process *p);
175
176 // Tell the scheduler not to initialize a process.
177 void dontInitialize(Process *p);
178
179 // Run the next process, if there is one.
180 void yield();
181
182 // Put a process on the ready list.
183 void ready(Process *p);
184
185 // Mark a process as ready if init is finished, or put it on the list of
186 // processes to be initialized.
187 void resume(Process *p);
188
189 // Remove a process from the ready/init list if it was on one of them, and
190 // return if it was.
191 bool suspend(Process *p);
192
193 // Schedule an update for a given channel.
194 void requestUpdate(Channel *c);
195
196 // Run the given process immediately, preempting whatever may be running.
197 void
198 runNow(Process *p)
199 {
200 // If a process is running, schedule it/us to run again.
201 if (_current)
202 readyList.pushFirst(_current);
203 // Schedule p to run first.
204 readyList.pushFirst(p);
205 yield();
206 }
207
208 // Set an event queue for scheduling events.
209 void setEventQueue(EventQueue *_eq) { eq = _eq; }
210
211 // Get the current time according to gem5.
212 Tick getCurTick() { return eq ? eq->getCurTick() : 0; }
213
214 Tick
215 delayed(const ::sc_core::sc_time &delay)
216 {
217 //XXX We're assuming the systemc time resolution is in ps.
218 return getCurTick() + delay.value() * SimClock::Int::ps;
219 }
220
221 // For scheduling delayed/timed notifications/timeouts.
222 void
223 schedule(ScEvent *event, const ::sc_core::sc_time &delay)
224 {
225 Tick tick = delayed(delay);
226 if (tick < getCurTick())
227 tick = getCurTick();
228
| 149
150 class TimeSlot : public ::Event
151 {
152 public:
153 TimeSlot() : ::Event(Default_Pri, AutoDelete) {}
154
155 ScEvents events;
156 void process();
157 };
158
159 typedef std::map<Tick, TimeSlot *> TimeSlots;
160
161 Scheduler();
162 ~Scheduler();
163
164 void clear();
165
166 const std::string name() const { return "systemc_scheduler"; }
167
168 uint64_t numCycles() { return _numCycles; }
169 Process *current() { return _current; }
170
171 void initPhase();
172
173 // Register a process with the scheduler.
174 void reg(Process *p);
175
176 // Tell the scheduler not to initialize a process.
177 void dontInitialize(Process *p);
178
179 // Run the next process, if there is one.
180 void yield();
181
182 // Put a process on the ready list.
183 void ready(Process *p);
184
185 // Mark a process as ready if init is finished, or put it on the list of
186 // processes to be initialized.
187 void resume(Process *p);
188
189 // Remove a process from the ready/init list if it was on one of them, and
190 // return if it was.
191 bool suspend(Process *p);
192
193 // Schedule an update for a given channel.
194 void requestUpdate(Channel *c);
195
196 // Run the given process immediately, preempting whatever may be running.
197 void
198 runNow(Process *p)
199 {
200 // If a process is running, schedule it/us to run again.
201 if (_current)
202 readyList.pushFirst(_current);
203 // Schedule p to run first.
204 readyList.pushFirst(p);
205 yield();
206 }
207
208 // Set an event queue for scheduling events.
209 void setEventQueue(EventQueue *_eq) { eq = _eq; }
210
211 // Get the current time according to gem5.
212 Tick getCurTick() { return eq ? eq->getCurTick() : 0; }
213
214 Tick
215 delayed(const ::sc_core::sc_time &delay)
216 {
217 //XXX We're assuming the systemc time resolution is in ps.
218 return getCurTick() + delay.value() * SimClock::Int::ps;
219 }
220
221 // For scheduling delayed/timed notifications/timeouts.
222 void
223 schedule(ScEvent *event, const ::sc_core::sc_time &delay)
224 {
225 Tick tick = delayed(delay);
226 if (tick < getCurTick())
227 tick = getCurTick();
228
|
229 event->schedule(tick);
230
| |
231 // Delta notification/timeout.
232 if (delay.value() == 0) {
| 229 // Delta notification/timeout.
230 if (delay.value() == 0) {
|
233 deltas.insert(event);
| 231 event->schedule(deltas, tick);
|
234 scheduleReadyEvent();
235 return;
236 }
237
238 // Timed notification/timeout.
239 TimeSlot *&ts = timeSlots[tick];
240 if (!ts) {
241 ts = new TimeSlot;
242 schedule(ts, tick);
243 }
| 232 scheduleReadyEvent();
233 return;
234 }
235
236 // Timed notification/timeout.
237 TimeSlot *&ts = timeSlots[tick];
238 if (!ts) {
239 ts = new TimeSlot;
240 schedule(ts, tick);
241 }
|
244 ts->events.insert(event);
| 242 event->schedule(ts->events, tick);
|
245 }
246
247 // For descheduling delayed/timed notifications/timeouts.
248 void
249 deschedule(ScEvent *event)
250 {
| 243 }
244
245 // For descheduling delayed/timed notifications/timeouts.
246 void
247 deschedule(ScEvent *event)
248 {
|
251 if (event->when() == getCurTick()) {
252 // Attempt to remove from delta notifications.
253 if (deltas.erase(event) == 1) {
254 event->deschedule();
255 return;
256 }
| 249 ScEvents *on = event->scheduledOn();
250
251 if (on == &deltas) {
252 event->deschedule();
253 return;
|
257 }
258
259 // Timed notification/timeout.
260 auto tsit = timeSlots.find(event->when());
261 panic_if(tsit == timeSlots.end(),
262 "Descheduling event at time with no events.");
263 TimeSlot *ts = tsit->second;
264 ScEvents &events = ts->events;
| 254 }
255
256 // Timed notification/timeout.
257 auto tsit = timeSlots.find(event->when());
258 panic_if(tsit == timeSlots.end(),
259 "Descheduling event at time with no events.");
260 TimeSlot *ts = tsit->second;
261 ScEvents &events = ts->events;
|
265 assert(events.erase(event));
| 262 assert(on == &events);
|
266 event->deschedule();
267
268 // If no more events are happening at this time slot, get rid of it.
269 if (events.empty()) {
270 deschedule(ts);
271 timeSlots.erase(tsit);
272 }
273 }
274
275 void
276 completeTimeSlot(TimeSlot *ts)
277 {
278 _changeStamp++;
279 assert(ts == timeSlots.begin()->second);
280 timeSlots.erase(timeSlots.begin());
281 if (!runToTime && starved())
282 scheduleStarvationEvent();
283 }
284
285 // Pending activity ignores gem5 activity, much like how a systemc
286 // simulation wouldn't know about asynchronous external events (socket IO
287 // for instance) that might happen before time advances in a pure
288 // systemc simulation. Also the spec lists what specific types of pending
289 // activity needs to be counted, which obviously doesn't include gem5
290 // events.
291
292 // Return whether there's pending systemc activity at this time.
293 bool
294 pendingCurr()
295 {
296 return !readyList.empty() || !updateList.empty() || !deltas.empty();
297 }
298
299 // Return whether there are pending timed notifications or timeouts.
300 bool
301 pendingFuture()
302 {
303 return !timeSlots.empty();
304 }
305
306 // Return how many ticks there are until the first pending event, if any.
307 Tick
308 timeToPending()
309 {
310 if (pendingCurr())
311 return 0;
312 if (pendingFuture())
313 return timeSlots.begin()->first - getCurTick();
314 return MaxTick - getCurTick();
315 }
316
317 // Run scheduled channel updates.
318 void update();
319
320 void setScMainFiber(Fiber *sc_main) { scMain = sc_main; }
321
322 void start(Tick max_tick, bool run_to_time);
323 void oneCycle();
324
325 void schedulePause();
326 void scheduleStop(bool finish_delta);
327
328 bool paused() { return _paused; }
329 bool stopped() { return _stopped; }
330
331 uint64_t changeStamp() { return _changeStamp; }
332
333 private:
334 typedef const EventBase::Priority Priority;
335 static Priority DefaultPriority = EventBase::Default_Pri;
336
337 static Priority StopPriority = DefaultPriority - 1;
338 static Priority PausePriority = DefaultPriority + 1;
339 static Priority MaxTickPriority = DefaultPriority + 2;
340 static Priority ReadyPriority = DefaultPriority + 3;
341 static Priority StarvationPriority = ReadyPriority;
342
343 EventQueue *eq;
344
345 // For gem5 style events.
346 void
347 schedule(::Event *event, Tick tick)
348 {
349 if (initDone)
350 eq->schedule(event, tick);
351 else
352 eventsToSchedule[event] = tick;
353 }
354
355 void schedule(::Event *event) { schedule(event, getCurTick()); }
356
357 void
358 deschedule(::Event *event)
359 {
360 if (initDone)
361 eq->deschedule(event);
362 else
363 eventsToSchedule.erase(event);
364 }
365
366 ScEvents deltas;
367 TimeSlots timeSlots;
368
369 void runReady();
370 EventWrapper<Scheduler, &Scheduler::runReady> readyEvent;
371 void scheduleReadyEvent();
372
373 void pause();
374 void stop();
375 EventWrapper<Scheduler, &Scheduler::pause> pauseEvent;
376 EventWrapper<Scheduler, &Scheduler::stop> stopEvent;
377 Fiber *scMain;
378
379 bool
380 starved()
381 {
382 return (readyList.empty() && updateList.empty() && deltas.empty() &&
383 (timeSlots.empty() || timeSlots.begin()->first > maxTick) &&
384 initList.empty());
385 }
386 EventWrapper<Scheduler, &Scheduler::pause> starvationEvent;
387 void scheduleStarvationEvent();
388
389 bool _started;
390 bool _paused;
391 bool _stopped;
392
393 Tick maxTick;
394 Tick lastReadyTick;
395 void
396 maxTickFunc()
397 {
398 if (lastReadyTick != getCurTick())
399 _changeStamp++;
400 pause();
401 }
402 EventWrapper<Scheduler, &Scheduler::maxTickFunc> maxTickEvent;
403
404 uint64_t _numCycles;
405 uint64_t _changeStamp;
406
407 Process *_current;
408
409 bool initDone;
410 bool runToTime;
411 bool runOnce;
412
413 ProcessList initList;
414 ProcessList toFinalize;
415 ProcessList readyList;
416
417 ChannelList updateList;
418
419 std::map<::Event *, Tick> eventsToSchedule;
420};
421
422extern Scheduler scheduler;
423
424inline void
425Scheduler::TimeSlot::process()
426{
| 263 event->deschedule();
264
265 // If no more events are happening at this time slot, get rid of it.
266 if (events.empty()) {
267 deschedule(ts);
268 timeSlots.erase(tsit);
269 }
270 }
271
272 void
273 completeTimeSlot(TimeSlot *ts)
274 {
275 _changeStamp++;
276 assert(ts == timeSlots.begin()->second);
277 timeSlots.erase(timeSlots.begin());
278 if (!runToTime && starved())
279 scheduleStarvationEvent();
280 }
281
282 // Pending activity ignores gem5 activity, much like how a systemc
283 // simulation wouldn't know about asynchronous external events (socket IO
284 // for instance) that might happen before time advances in a pure
285 // systemc simulation. Also the spec lists what specific types of pending
286 // activity needs to be counted, which obviously doesn't include gem5
287 // events.
288
289 // Return whether there's pending systemc activity at this time.
290 bool
291 pendingCurr()
292 {
293 return !readyList.empty() || !updateList.empty() || !deltas.empty();
294 }
295
296 // Return whether there are pending timed notifications or timeouts.
297 bool
298 pendingFuture()
299 {
300 return !timeSlots.empty();
301 }
302
303 // Return how many ticks there are until the first pending event, if any.
304 Tick
305 timeToPending()
306 {
307 if (pendingCurr())
308 return 0;
309 if (pendingFuture())
310 return timeSlots.begin()->first - getCurTick();
311 return MaxTick - getCurTick();
312 }
313
314 // Run scheduled channel updates.
315 void update();
316
317 void setScMainFiber(Fiber *sc_main) { scMain = sc_main; }
318
319 void start(Tick max_tick, bool run_to_time);
320 void oneCycle();
321
322 void schedulePause();
323 void scheduleStop(bool finish_delta);
324
325 bool paused() { return _paused; }
326 bool stopped() { return _stopped; }
327
328 uint64_t changeStamp() { return _changeStamp; }
329
330 private:
331 typedef const EventBase::Priority Priority;
332 static Priority DefaultPriority = EventBase::Default_Pri;
333
334 static Priority StopPriority = DefaultPriority - 1;
335 static Priority PausePriority = DefaultPriority + 1;
336 static Priority MaxTickPriority = DefaultPriority + 2;
337 static Priority ReadyPriority = DefaultPriority + 3;
338 static Priority StarvationPriority = ReadyPriority;
339
340 EventQueue *eq;
341
342 // For gem5 style events.
343 void
344 schedule(::Event *event, Tick tick)
345 {
346 if (initDone)
347 eq->schedule(event, tick);
348 else
349 eventsToSchedule[event] = tick;
350 }
351
352 void schedule(::Event *event) { schedule(event, getCurTick()); }
353
354 void
355 deschedule(::Event *event)
356 {
357 if (initDone)
358 eq->deschedule(event);
359 else
360 eventsToSchedule.erase(event);
361 }
362
363 ScEvents deltas;
364 TimeSlots timeSlots;
365
366 void runReady();
367 EventWrapper<Scheduler, &Scheduler::runReady> readyEvent;
368 void scheduleReadyEvent();
369
370 void pause();
371 void stop();
372 EventWrapper<Scheduler, &Scheduler::pause> pauseEvent;
373 EventWrapper<Scheduler, &Scheduler::stop> stopEvent;
374 Fiber *scMain;
375
376 bool
377 starved()
378 {
379 return (readyList.empty() && updateList.empty() && deltas.empty() &&
380 (timeSlots.empty() || timeSlots.begin()->first > maxTick) &&
381 initList.empty());
382 }
383 EventWrapper<Scheduler, &Scheduler::pause> starvationEvent;
384 void scheduleStarvationEvent();
385
386 bool _started;
387 bool _paused;
388 bool _stopped;
389
390 Tick maxTick;
391 Tick lastReadyTick;
392 void
393 maxTickFunc()
394 {
395 if (lastReadyTick != getCurTick())
396 _changeStamp++;
397 pause();
398 }
399 EventWrapper<Scheduler, &Scheduler::maxTickFunc> maxTickEvent;
400
401 uint64_t _numCycles;
402 uint64_t _changeStamp;
403
404 Process *_current;
405
406 bool initDone;
407 bool runToTime;
408 bool runOnce;
409
410 ProcessList initList;
411 ProcessList toFinalize;
412 ProcessList readyList;
413
414 ChannelList updateList;
415
416 std::map<::Event *, Tick> eventsToSchedule;
417};
418
419extern Scheduler scheduler;
420
421inline void
422Scheduler::TimeSlot::process()
423{
|
427 for (auto &e: events)
428 e->run();
| 424 while (!events.empty())
425 events.front()->run();
|
429 scheduler.completeTimeSlot(this);
430}
431
432} // namespace sc_gem5
433
434#endif // __SYSTEMC_CORE_SCHEDULER_H__
| 426 scheduler.completeTimeSlot(this);
427}
428
429} // namespace sc_gem5
430
431#endif // __SYSTEMC_CORE_SCHEDULER_H__
|