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;
| 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;
|