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;
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();
| 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;
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
163 const std::string name() const { return "systemc_scheduler"; }
164
165 uint64_t numCycles() { return _numCycles; }
166 Process *current() { return _current; }
167
168 void initPhase();
169
170 // Register a process with the scheduler.
171 void reg(Process *p);
172
173 // Tell the scheduler not to initialize a process.
174 void dontInitialize(Process *p);
175
176 // Run the next process, if there is one.
177 void yield();
178
179 // Put a process on the ready list.
180 void ready(Process *p);
181
182 // Schedule an update for a given channel.
183 void requestUpdate(Channel *c);
184
185 // Run the given process immediately, preempting whatever may be running.
186 void
187 runNow(Process *p)
188 {
189 // If a process is running, schedule it/us to run again.
190 if (_current)
191 readyList.pushFirst(_current);
192 // Schedule p to run first.
193 readyList.pushFirst(p);
194 yield();
195 }
196
197 // Set an event queue for scheduling events.
198 void setEventQueue(EventQueue *_eq) { eq = _eq; }
199
200 // Get the current time according to gem5.
201 Tick getCurTick() { return eq ? eq->getCurTick() : 0; }
202
203 Tick
204 delayed(const ::sc_core::sc_time &delay)
205 {
206 //XXX We're assuming the systemc time resolution is in ps.
207 return getCurTick() + delay.value() * SimClock::Int::ps;
208 }
209
210 // For scheduling delayed/timed notifications/timeouts.
211 void
212 schedule(ScEvent *event, const ::sc_core::sc_time &delay)
213 {
214 Tick tick = delayed(delay);
215 event->schedule(tick);
216
217 // Delta notification/timeout.
218 if (delay.value() == 0) {
219 deltas.insert(event);
220 scheduleReadyEvent();
221 return;
222 }
223
224 // Timed notification/timeout.
225 TimeSlot *&ts = timeSlots[tick];
226 if (!ts) {
227 ts = new TimeSlot;
228 schedule(ts, tick);
229 }
230 ts->events.insert(event);
231 }
232
233 // For descheduling delayed/timed notifications/timeouts.
234 void
235 deschedule(ScEvent *event)
236 {
237 if (event->when() == getCurTick()) {
238 // Remove from delta notifications.
239 deltas.erase(event);
240 event->deschedule();
241 return;
242 }
243
244 // Timed notification/timeout.
245 auto tsit = timeSlots.find(event->when());
246 panic_if(tsit == timeSlots.end(),
247 "Descheduling event at time with no events.");
248 TimeSlot *ts = tsit->second;
249 ScEvents &events = ts->events;
250 events.erase(event);
251 event->deschedule();
252
253 // If no more events are happening at this time slot, get rid of it.
254 if (events.empty()) {
255 deschedule(ts);
256 timeSlots.erase(tsit);
257 }
258 }
259
260 void
261 completeTimeSlot(TimeSlot *ts)
262 {
263 assert(ts == timeSlots.begin()->second);
264 timeSlots.erase(timeSlots.begin());
265 }
266
267 // Pending activity ignores gem5 activity, much like how a systemc
268 // simulation wouldn't know about asynchronous external events (socket IO
269 // for instance) that might happen before time advances in a pure
270 // systemc simulation. Also the spec lists what specific types of pending
271 // activity needs to be counted, which obviously doesn't include gem5
272 // events.
273
274 // Return whether there's pending systemc activity at this time.
275 bool
276 pendingCurr()
277 {
278 return !readyList.empty() || !updateList.empty() || !deltas.empty();
279 }
280
281 // Return whether there are pending timed notifications or timeouts.
282 bool
283 pendingFuture()
284 {
285 return !timeSlots.empty();
286 }
287
288 // Return how many ticks there are until the first pending event, if any.
289 Tick
290 timeToPending()
291 {
292 if (pendingCurr())
293 return 0;
294 if (pendingFuture())
295 return timeSlots.begin()->first - getCurTick();
296 return MaxTick - getCurTick();
297 }
298
299 // Run scheduled channel updates.
300 void update();
301
302 void setScMainFiber(Fiber *sc_main) { scMain = sc_main; }
303
304 void start(Tick max_tick, bool run_to_time);
305 void oneCycle();
306
307 void schedulePause();
308 void scheduleStop(bool finish_delta);
309
310 bool paused() { return _paused; }
311 bool stopped() { return _stopped; }
312
313 private:
314 typedef const EventBase::Priority Priority;
315 static Priority DefaultPriority = EventBase::Default_Pri;
316
317 static Priority StopPriority = DefaultPriority - 1;
318 static Priority PausePriority = DefaultPriority + 1;
319 static Priority MaxTickPriority = DefaultPriority + 2;
320 static Priority ReadyPriority = DefaultPriority + 3;
321 static Priority StarvationPriority = ReadyPriority;
322
323 EventQueue *eq;
324
325 // For gem5 style events.
326 void
327 schedule(::Event *event, Tick tick)
328 {
329 if (initDone)
330 eq->schedule(event, tick);
331 else
332 eventsToSchedule[event] = tick;
333 }
334
335 void schedule(::Event *event) { schedule(event, getCurTick()); }
336
337 void
338 deschedule(::Event *event)
339 {
340 if (initDone)
341 eq->deschedule(event);
342 else
343 eventsToSchedule.erase(event);
344 }
345
346 ScEvents deltas;
347 TimeSlots timeSlots;
348
349 void runReady();
350 EventWrapper<Scheduler, &Scheduler::runReady> readyEvent;
351 void scheduleReadyEvent();
352
353 void pause();
354 void stop();
355 EventWrapper<Scheduler, &Scheduler::pause> pauseEvent;
356 EventWrapper<Scheduler, &Scheduler::stop> stopEvent;
357 Fiber *scMain;
358
359 bool
360 starved()
361 {
362 return (readyList.empty() && updateList.empty() && deltas.empty() &&
363 (timeSlots.empty() || timeSlots.begin()->first > maxTick) &&
364 initList.empty());
365 }
366 EventWrapper<Scheduler, &Scheduler::pause> starvationEvent;
367 void scheduleStarvationEvent();
368
369 bool _started;
370 bool _paused;
371 bool _stopped;
372
373 Tick maxTick;
374 EventWrapper<Scheduler, &Scheduler::pause> maxTickEvent;
375
376 uint64_t _numCycles;
377
378 Process *_current;
379
380 bool initDone;
381 bool runToTime;
382 bool runOnce;
383
384 ProcessList initList;
385 ProcessList toFinalize;
386 ProcessList readyList;
387
388 ChannelList updateList;
389
390 std::map<::Event *, Tick> eventsToSchedule;
391};
392
393extern Scheduler scheduler;
394
395inline void
396Scheduler::TimeSlot::process()
397{
398 for (auto &e: events)
399 e->run();
400 scheduler.completeTimeSlot(this);
401}
402
403} // namespace sc_gem5
404
405#endif // __SYSTEMC_CORE_SCHEDULER_H__
| 163
164 const std::string name() const { return "systemc_scheduler"; }
165
166 uint64_t numCycles() { return _numCycles; }
167 Process *current() { return _current; }
168
169 void initPhase();
170
171 // Register a process with the scheduler.
172 void reg(Process *p);
173
174 // Tell the scheduler not to initialize a process.
175 void dontInitialize(Process *p);
176
177 // Run the next process, if there is one.
178 void yield();
179
180 // Put a process on the ready list.
181 void ready(Process *p);
182
183 // Schedule an update for a given channel.
184 void requestUpdate(Channel *c);
185
186 // Run the given process immediately, preempting whatever may be running.
187 void
188 runNow(Process *p)
189 {
190 // If a process is running, schedule it/us to run again.
191 if (_current)
192 readyList.pushFirst(_current);
193 // Schedule p to run first.
194 readyList.pushFirst(p);
195 yield();
196 }
197
198 // Set an event queue for scheduling events.
199 void setEventQueue(EventQueue *_eq) { eq = _eq; }
200
201 // Get the current time according to gem5.
202 Tick getCurTick() { return eq ? eq->getCurTick() : 0; }
203
204 Tick
205 delayed(const ::sc_core::sc_time &delay)
206 {
207 //XXX We're assuming the systemc time resolution is in ps.
208 return getCurTick() + delay.value() * SimClock::Int::ps;
209 }
210
211 // For scheduling delayed/timed notifications/timeouts.
212 void
213 schedule(ScEvent *event, const ::sc_core::sc_time &delay)
214 {
215 Tick tick = delayed(delay);
216 event->schedule(tick);
217
218 // Delta notification/timeout.
219 if (delay.value() == 0) {
220 deltas.insert(event);
221 scheduleReadyEvent();
222 return;
223 }
224
225 // Timed notification/timeout.
226 TimeSlot *&ts = timeSlots[tick];
227 if (!ts) {
228 ts = new TimeSlot;
229 schedule(ts, tick);
230 }
231 ts->events.insert(event);
232 }
233
234 // For descheduling delayed/timed notifications/timeouts.
235 void
236 deschedule(ScEvent *event)
237 {
238 if (event->when() == getCurTick()) {
239 // Remove from delta notifications.
240 deltas.erase(event);
241 event->deschedule();
242 return;
243 }
244
245 // Timed notification/timeout.
246 auto tsit = timeSlots.find(event->when());
247 panic_if(tsit == timeSlots.end(),
248 "Descheduling event at time with no events.");
249 TimeSlot *ts = tsit->second;
250 ScEvents &events = ts->events;
251 events.erase(event);
252 event->deschedule();
253
254 // If no more events are happening at this time slot, get rid of it.
255 if (events.empty()) {
256 deschedule(ts);
257 timeSlots.erase(tsit);
258 }
259 }
260
261 void
262 completeTimeSlot(TimeSlot *ts)
263 {
264 assert(ts == timeSlots.begin()->second);
265 timeSlots.erase(timeSlots.begin());
266 }
267
268 // Pending activity ignores gem5 activity, much like how a systemc
269 // simulation wouldn't know about asynchronous external events (socket IO
270 // for instance) that might happen before time advances in a pure
271 // systemc simulation. Also the spec lists what specific types of pending
272 // activity needs to be counted, which obviously doesn't include gem5
273 // events.
274
275 // Return whether there's pending systemc activity at this time.
276 bool
277 pendingCurr()
278 {
279 return !readyList.empty() || !updateList.empty() || !deltas.empty();
280 }
281
282 // Return whether there are pending timed notifications or timeouts.
283 bool
284 pendingFuture()
285 {
286 return !timeSlots.empty();
287 }
288
289 // Return how many ticks there are until the first pending event, if any.
290 Tick
291 timeToPending()
292 {
293 if (pendingCurr())
294 return 0;
295 if (pendingFuture())
296 return timeSlots.begin()->first - getCurTick();
297 return MaxTick - getCurTick();
298 }
299
300 // Run scheduled channel updates.
301 void update();
302
303 void setScMainFiber(Fiber *sc_main) { scMain = sc_main; }
304
305 void start(Tick max_tick, bool run_to_time);
306 void oneCycle();
307
308 void schedulePause();
309 void scheduleStop(bool finish_delta);
310
311 bool paused() { return _paused; }
312 bool stopped() { return _stopped; }
313
314 private:
315 typedef const EventBase::Priority Priority;
316 static Priority DefaultPriority = EventBase::Default_Pri;
317
318 static Priority StopPriority = DefaultPriority - 1;
319 static Priority PausePriority = DefaultPriority + 1;
320 static Priority MaxTickPriority = DefaultPriority + 2;
321 static Priority ReadyPriority = DefaultPriority + 3;
322 static Priority StarvationPriority = ReadyPriority;
323
324 EventQueue *eq;
325
326 // For gem5 style events.
327 void
328 schedule(::Event *event, Tick tick)
329 {
330 if (initDone)
331 eq->schedule(event, tick);
332 else
333 eventsToSchedule[event] = tick;
334 }
335
336 void schedule(::Event *event) { schedule(event, getCurTick()); }
337
338 void
339 deschedule(::Event *event)
340 {
341 if (initDone)
342 eq->deschedule(event);
343 else
344 eventsToSchedule.erase(event);
345 }
346
347 ScEvents deltas;
348 TimeSlots timeSlots;
349
350 void runReady();
351 EventWrapper<Scheduler, &Scheduler::runReady> readyEvent;
352 void scheduleReadyEvent();
353
354 void pause();
355 void stop();
356 EventWrapper<Scheduler, &Scheduler::pause> pauseEvent;
357 EventWrapper<Scheduler, &Scheduler::stop> stopEvent;
358 Fiber *scMain;
359
360 bool
361 starved()
362 {
363 return (readyList.empty() && updateList.empty() && deltas.empty() &&
364 (timeSlots.empty() || timeSlots.begin()->first > maxTick) &&
365 initList.empty());
366 }
367 EventWrapper<Scheduler, &Scheduler::pause> starvationEvent;
368 void scheduleStarvationEvent();
369
370 bool _started;
371 bool _paused;
372 bool _stopped;
373
374 Tick maxTick;
375 EventWrapper<Scheduler, &Scheduler::pause> maxTickEvent;
376
377 uint64_t _numCycles;
378
379 Process *_current;
380
381 bool initDone;
382 bool runToTime;
383 bool runOnce;
384
385 ProcessList initList;
386 ProcessList toFinalize;
387 ProcessList readyList;
388
389 ChannelList updateList;
390
391 std::map<::Event *, Tick> eventsToSchedule;
392};
393
394extern Scheduler scheduler;
395
396inline void
397Scheduler::TimeSlot::process()
398{
399 for (auto &e: events)
400 e->run();
401 scheduler.completeTimeSlot(this);
402}
403
404} // namespace sc_gem5
405
406#endif // __SYSTEMC_CORE_SCHEDULER_H__
|