scheduler.hh revision 12961:9bd3a469fd11
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 // Retrieve the event queue. 183 EventQueue &eventQueue() const { return *eq; } 184 185 // Run scheduled channel updates. 186 void update(); 187 188 void setScMainFiber(Fiber *sc_main) { scMain = sc_main; } 189 190 void start(Tick max_tick, bool run_to_time); 191 192 void schedulePause(); 193 void scheduleStop(bool finish_delta); 194 195 bool paused() { return _paused; } 196 bool stopped() { return _stopped; } 197 198 private: 199 typedef const EventBase::Priority Priority; 200 static Priority DefaultPriority = EventBase::Default_Pri; 201 202 static Priority StopPriority = DefaultPriority - 1; 203 static Priority PausePriority = DefaultPriority + 1; 204 static Priority ReadyPriority = DefaultPriority + 2; 205 static Priority MaxTickPriority = DefaultPriority + 3; 206 207 EventQueue *eq; 208 209 void runReady(); 210 EventWrapper<Scheduler, &Scheduler::runReady> readyEvent; 211 void scheduleReadyEvent(); 212 213 void pause(); 214 void stop(); 215 EventWrapper<Scheduler, &Scheduler::pause> pauseEvent; 216 EventWrapper<Scheduler, &Scheduler::stop> stopEvent; 217 Fiber *scMain; 218 219 bool _started; 220 bool _paused; 221 bool _stopped; 222 223 Tick maxTick; 224 EventWrapper<Scheduler, &Scheduler::pause> maxTickEvent; 225 226 uint64_t _numCycles; 227 228 Process *_current; 229 230 bool initReady; 231 232 ProcessList initList; 233 ProcessList toFinalize; 234 ProcessList readyList; 235 236 ChannelList updateList; 237}; 238 239extern Scheduler scheduler; 240 241} // namespace sc_gem5 242 243#endif // __SYSTEMC_CORE_SCHEDULER_H__ 244