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 <vector>
34
35#include "base/logging.hh"
36#include "sim/eventq.hh"
37#include "systemc/core/channel.hh"
38#include "systemc/core/list.hh"
39#include "systemc/core/process.hh"
40
41class Fiber;
42
43namespace sc_gem5
44{
45
46typedef NodeList<Process> ProcessList;
47typedef NodeList<Channel> ChannelList;
48
49/*
50 * The scheduler supports three different mechanisms, the initialization phase,
51 * delta cycles, and timed notifications.
52 *
53 * INITIALIZATION PHASE
54 *
55 * The initialization phase has three parts:
56 * 1. Run requested channel updates.
57 * 2. Make processes which need to initialize runnable (methods and threads
58 * which didn't have dont_initialize called on them).
59 * 3. Process delta notifications.
60 *
61 * First, the Kernel SimObject calls the update() method during its startup()
62 * callback which handles the requested channel updates. The Kernel also
63 * schedules an event to be run at time 0 with a slightly elevated priority
64 * so that it happens before any "normal" event.
65 *
66 * When that t0 event happens, it calls the schedulers prepareForInit method
67 * which performs step 2 above. That indirectly causes the scheduler's
68 * readyEvent to be scheduled with slightly lowered priority, ensuring it
69 * happens after any "normal" event.
70 *
71 * Because delta notifications are scheduled at the standard priority, all
72 * of those events will happen next, performing step 3 above. Once they finish,
73 * if the readyEvent was scheduled above, there shouldn't be any higher
74 * priority events in front of it. When it runs, it will start the first
75 * evaluate phase of the first delta cycle.
76 *
77 * DELTA CYCLE
78 *
79 * A delta cycle has three phases within it.
80 * 1. The evaluate phase where runnable processes are allowed to run.
81 * 2. The update phase where requested channel updates hapen.
82 * 3. The delta notification phase where delta notifications happen.
83 *
84 * The readyEvent runs the first two steps of the delta cycle. It first goes
85 * through the list of runnable processes and executes them until the set is
86 * empty, and then immediately runs the update phase. Since these are all part
87 * of the same event, there's no chance for other events to intervene and
88 * break the required order above.
89 *
90 * During the update phase above, the spec forbids any action which would make
91 * a process runnable. That means that once the update phase finishes, the set
92 * of runnable processes will be empty. There may, however, have been some
93 * delta notifications/timeouts which will have been scheduled during either
94 * the evaluate or update phase above. Because those are scheduled at the
95 * normal priority, they will now happen together until there aren't any
96 * delta events left.
97 *
98 * If any processes became runnable during the delta notification phase, the
99 * readyEvent will have been scheduled and will have been waiting patiently
100 * behind the delta notification events. That will now run, effectively
101 * starting the next delta cycle.
102 *
103 * TIMED NOTIFICATION PHASE
104 *
105 * If no processes became runnable, the event queue will continue to process
106 * events until it comes across a timed notification, aka a notification
107 * scheduled to happen in the future. Like delta notification events, those
108 * will all happen together since the readyEvent priority is lower,
109 * potentially marking new processes as ready. Once these events finish, the
110 * readyEvent may run, starting the next delta cycle.
111 *
112 * PAUSE/STOP
113 *
114 * To inject a pause from sc_pause which should happen after the current delta
115 * cycle's delta notification phase, an event is scheduled with a lower than
116 * normal priority, but higher than the readyEvent. That ensures that any
117 * delta notifications which are scheduled with normal priority will happen
118 * first, since those are part of the current delta cycle. Then the pause
119 * event will happen before the next readyEvent which would start the next
120 * delta cycle. All of these events are scheduled for the current time, and so
121 * would happen before any timed notifications went off.
122 *
123 * To inject a stop from sc_stop, the delta cycles should stop before even the
124 * delta notifications have happened, but after the evaluate and update phases.
125 * For that, a stop event with slightly higher than normal priority will be
126 * scheduled so that it happens before any of the delta notification events
127 * which are at normal priority.
128 *
129 * MAX RUN TIME
130 *
131 * When sc_start is called, it's possible to pass in a maximum time the
132 * simulation should run to, at which point sc_pause is implicitly called.
133 * That's implemented by scheduling an event at the max time with a priority
134 * which is lower than all the others so that it happens only if time would
135 * advance. When that event triggers, it calls the same function as the pause
136 * event.
137 */
138
139class Scheduler
140{
141 public:
142 Scheduler();
143
144 const std::string name() const { return "systemc_scheduler"; }
145
146 uint64_t numCycles() { return _numCycles; }
147 Process *current() { return _current; }
148
149 // Prepare for initialization.
150 void prepareForInit();
151
152 // Register a process with the scheduler.
153 void reg(Process *p);
154
155 // Tell the scheduler not to initialize a process.
156 void dontInitialize(Process *p);
157
158 // Run the next process, if there is one.
159 void yield();
160
161 // Put a process on the ready list.
162 void ready(Process *p);
163
164 // Schedule an update for a given channel.
165 void requestUpdate(Channel *c);
166
167 // Run the given process immediately, preempting whatever may be running.
168 void
169 runNow(Process *p)
170 {
171 // If a process is running, schedule it/us to run again.
172 if (_current)
173 readyList.pushFirst(_current);
174 // Schedule p to run first.
175 readyList.pushFirst(p);
176 yield();
177 }
178
179 // Set an event queue for scheduling events.
180 void setEventQueue(EventQueue *_eq) { eq = _eq; }
181
182 // Get the current time according to gem5.
183 Tick getCurTick() { return eq ? eq->getCurTick() : 0; }
184
185 // For scheduling delayed/timed notifications/timeouts.
186 void
187 schedule(::Event *event, Tick tick)
188 {
189 pendingTicks[tick]++;
| 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 <vector>
34
35#include "base/logging.hh"
36#include "sim/eventq.hh"
37#include "systemc/core/channel.hh"
38#include "systemc/core/list.hh"
39#include "systemc/core/process.hh"
40
41class Fiber;
42
43namespace sc_gem5
44{
45
46typedef NodeList<Process> ProcessList;
47typedef NodeList<Channel> ChannelList;
48
49/*
50 * The scheduler supports three different mechanisms, the initialization phase,
51 * delta cycles, and timed notifications.
52 *
53 * INITIALIZATION PHASE
54 *
55 * The initialization phase has three parts:
56 * 1. Run requested channel updates.
57 * 2. Make processes which need to initialize runnable (methods and threads
58 * which didn't have dont_initialize called on them).
59 * 3. Process delta notifications.
60 *
61 * First, the Kernel SimObject calls the update() method during its startup()
62 * callback which handles the requested channel updates. The Kernel also
63 * schedules an event to be run at time 0 with a slightly elevated priority
64 * so that it happens before any "normal" event.
65 *
66 * When that t0 event happens, it calls the schedulers prepareForInit method
67 * which performs step 2 above. That indirectly causes the scheduler's
68 * readyEvent to be scheduled with slightly lowered priority, ensuring it
69 * happens after any "normal" event.
70 *
71 * Because delta notifications are scheduled at the standard priority, all
72 * of those events will happen next, performing step 3 above. Once they finish,
73 * if the readyEvent was scheduled above, there shouldn't be any higher
74 * priority events in front of it. When it runs, it will start the first
75 * evaluate phase of the first delta cycle.
76 *
77 * DELTA CYCLE
78 *
79 * A delta cycle has three phases within it.
80 * 1. The evaluate phase where runnable processes are allowed to run.
81 * 2. The update phase where requested channel updates hapen.
82 * 3. The delta notification phase where delta notifications happen.
83 *
84 * The readyEvent runs the first two steps of the delta cycle. It first goes
85 * through the list of runnable processes and executes them until the set is
86 * empty, and then immediately runs the update phase. Since these are all part
87 * of the same event, there's no chance for other events to intervene and
88 * break the required order above.
89 *
90 * During the update phase above, the spec forbids any action which would make
91 * a process runnable. That means that once the update phase finishes, the set
92 * of runnable processes will be empty. There may, however, have been some
93 * delta notifications/timeouts which will have been scheduled during either
94 * the evaluate or update phase above. Because those are scheduled at the
95 * normal priority, they will now happen together until there aren't any
96 * delta events left.
97 *
98 * If any processes became runnable during the delta notification phase, the
99 * readyEvent will have been scheduled and will have been waiting patiently
100 * behind the delta notification events. That will now run, effectively
101 * starting the next delta cycle.
102 *
103 * TIMED NOTIFICATION PHASE
104 *
105 * If no processes became runnable, the event queue will continue to process
106 * events until it comes across a timed notification, aka a notification
107 * scheduled to happen in the future. Like delta notification events, those
108 * will all happen together since the readyEvent priority is lower,
109 * potentially marking new processes as ready. Once these events finish, the
110 * readyEvent may run, starting the next delta cycle.
111 *
112 * PAUSE/STOP
113 *
114 * To inject a pause from sc_pause which should happen after the current delta
115 * cycle's delta notification phase, an event is scheduled with a lower than
116 * normal priority, but higher than the readyEvent. That ensures that any
117 * delta notifications which are scheduled with normal priority will happen
118 * first, since those are part of the current delta cycle. Then the pause
119 * event will happen before the next readyEvent which would start the next
120 * delta cycle. All of these events are scheduled for the current time, and so
121 * would happen before any timed notifications went off.
122 *
123 * To inject a stop from sc_stop, the delta cycles should stop before even the
124 * delta notifications have happened, but after the evaluate and update phases.
125 * For that, a stop event with slightly higher than normal priority will be
126 * scheduled so that it happens before any of the delta notification events
127 * which are at normal priority.
128 *
129 * MAX RUN TIME
130 *
131 * When sc_start is called, it's possible to pass in a maximum time the
132 * simulation should run to, at which point sc_pause is implicitly called.
133 * That's implemented by scheduling an event at the max time with a priority
134 * which is lower than all the others so that it happens only if time would
135 * advance. When that event triggers, it calls the same function as the pause
136 * event.
137 */
138
139class Scheduler
140{
141 public:
142 Scheduler();
143
144 const std::string name() const { return "systemc_scheduler"; }
145
146 uint64_t numCycles() { return _numCycles; }
147 Process *current() { return _current; }
148
149 // Prepare for initialization.
150 void prepareForInit();
151
152 // Register a process with the scheduler.
153 void reg(Process *p);
154
155 // Tell the scheduler not to initialize a process.
156 void dontInitialize(Process *p);
157
158 // Run the next process, if there is one.
159 void yield();
160
161 // Put a process on the ready list.
162 void ready(Process *p);
163
164 // Schedule an update for a given channel.
165 void requestUpdate(Channel *c);
166
167 // Run the given process immediately, preempting whatever may be running.
168 void
169 runNow(Process *p)
170 {
171 // If a process is running, schedule it/us to run again.
172 if (_current)
173 readyList.pushFirst(_current);
174 // Schedule p to run first.
175 readyList.pushFirst(p);
176 yield();
177 }
178
179 // Set an event queue for scheduling events.
180 void setEventQueue(EventQueue *_eq) { eq = _eq; }
181
182 // Get the current time according to gem5.
183 Tick getCurTick() { return eq ? eq->getCurTick() : 0; }
184
185 // For scheduling delayed/timed notifications/timeouts.
186 void
187 schedule(::Event *event, Tick tick)
188 {
189 pendingTicks[tick]++;
|
201 }
202
203 // Tell the scheduler than an event fired for bookkeeping purposes.
204 void
205 eventHappened()
206 {
207 auto it = pendingTicks.begin();
208 if (--it->second == 0)
209 pendingTicks.erase(it);
210 }
211
212 // Pending activity ignores gem5 activity, much like how a systemc
213 // simulation wouldn't know about asynchronous external events (socket IO
214 // for instance) that might happen before time advances in a pure
215 // systemc simulation. Also the spec lists what specific types of pending
216 // activity needs to be counted, which obviously doesn't include gem5
217 // events.
218
219 // Return whether there's pending systemc activity at this time.
220 bool
221 pendingCurr()
222 {
223 if (!readyList.empty() || !updateList.empty())
224 return true;
225 return pendingTicks.size() &&
226 pendingTicks.begin()->first == getCurTick();
227 }
228
229 // Return whether there are pending timed notifications or timeouts.
230 bool
231 pendingFuture()
232 {
233 switch (pendingTicks.size()) {
234 case 0: return false;
235 case 1: return pendingTicks.begin()->first > getCurTick();
236 default: return true;
237 }
238 }
239
240 // Return how many ticks there are until the first pending event, if any.
241 Tick
242 timeToPending()
243 {
244 if (!readyList.empty() || !updateList.empty())
245 return 0;
246 else if (pendingTicks.size())
247 return pendingTicks.begin()->first - getCurTick();
248 else
249 return MaxTick - getCurTick();
250 }
251
252 // Run scheduled channel updates.
253 void update();
254
255 void setScMainFiber(Fiber *sc_main) { scMain = sc_main; }
256
257 void start(Tick max_tick, bool run_to_time);
258
259 void schedulePause();
260 void scheduleStop(bool finish_delta);
261
262 bool paused() { return _paused; }
263 bool stopped() { return _stopped; }
264
265 private:
266 typedef const EventBase::Priority Priority;
267 static Priority DefaultPriority = EventBase::Default_Pri;
268
269 static Priority StopPriority = DefaultPriority - 1;
270 static Priority PausePriority = DefaultPriority + 1;
271 static Priority ReadyPriority = DefaultPriority + 2;
272 static Priority MaxTickPriority = DefaultPriority + 3;
273
274 EventQueue *eq;
275 std::map<Tick, int> pendingTicks;
276
277 void runReady();
278 EventWrapper<Scheduler, &Scheduler::runReady> readyEvent;
279 void scheduleReadyEvent();
280
281 void pause();
282 void stop();
283 EventWrapper<Scheduler, &Scheduler::pause> pauseEvent;
284 EventWrapper<Scheduler, &Scheduler::stop> stopEvent;
285 Fiber *scMain;
286
287 bool _started;
288 bool _paused;
289 bool _stopped;
290
291 Tick maxTick;
292 EventWrapper<Scheduler, &Scheduler::pause> maxTickEvent;
293
294 uint64_t _numCycles;
295
296 Process *_current;
297
298 bool initReady;
299
300 ProcessList initList;
301 ProcessList toFinalize;
302 ProcessList readyList;
303
304 ChannelList updateList;
| 209 }
210
211 // Tell the scheduler than an event fired for bookkeeping purposes.
212 void
213 eventHappened()
214 {
215 auto it = pendingTicks.begin();
216 if (--it->second == 0)
217 pendingTicks.erase(it);
218 }
219
220 // Pending activity ignores gem5 activity, much like how a systemc
221 // simulation wouldn't know about asynchronous external events (socket IO
222 // for instance) that might happen before time advances in a pure
223 // systemc simulation. Also the spec lists what specific types of pending
224 // activity needs to be counted, which obviously doesn't include gem5
225 // events.
226
227 // Return whether there's pending systemc activity at this time.
228 bool
229 pendingCurr()
230 {
231 if (!readyList.empty() || !updateList.empty())
232 return true;
233 return pendingTicks.size() &&
234 pendingTicks.begin()->first == getCurTick();
235 }
236
237 // Return whether there are pending timed notifications or timeouts.
238 bool
239 pendingFuture()
240 {
241 switch (pendingTicks.size()) {
242 case 0: return false;
243 case 1: return pendingTicks.begin()->first > getCurTick();
244 default: return true;
245 }
246 }
247
248 // Return how many ticks there are until the first pending event, if any.
249 Tick
250 timeToPending()
251 {
252 if (!readyList.empty() || !updateList.empty())
253 return 0;
254 else if (pendingTicks.size())
255 return pendingTicks.begin()->first - getCurTick();
256 else
257 return MaxTick - getCurTick();
258 }
259
260 // Run scheduled channel updates.
261 void update();
262
263 void setScMainFiber(Fiber *sc_main) { scMain = sc_main; }
264
265 void start(Tick max_tick, bool run_to_time);
266
267 void schedulePause();
268 void scheduleStop(bool finish_delta);
269
270 bool paused() { return _paused; }
271 bool stopped() { return _stopped; }
272
273 private:
274 typedef const EventBase::Priority Priority;
275 static Priority DefaultPriority = EventBase::Default_Pri;
276
277 static Priority StopPriority = DefaultPriority - 1;
278 static Priority PausePriority = DefaultPriority + 1;
279 static Priority ReadyPriority = DefaultPriority + 2;
280 static Priority MaxTickPriority = DefaultPriority + 3;
281
282 EventQueue *eq;
283 std::map<Tick, int> pendingTicks;
284
285 void runReady();
286 EventWrapper<Scheduler, &Scheduler::runReady> readyEvent;
287 void scheduleReadyEvent();
288
289 void pause();
290 void stop();
291 EventWrapper<Scheduler, &Scheduler::pause> pauseEvent;
292 EventWrapper<Scheduler, &Scheduler::stop> stopEvent;
293 Fiber *scMain;
294
295 bool _started;
296 bool _paused;
297 bool _stopped;
298
299 Tick maxTick;
300 EventWrapper<Scheduler, &Scheduler::pause> maxTickEvent;
301
302 uint64_t _numCycles;
303
304 Process *_current;
305
306 bool initReady;
307
308 ProcessList initList;
309 ProcessList toFinalize;
310 ProcessList readyList;
311
312 ChannelList updateList;
|