scheduler.cc revision 13095
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#include "systemc/core/scheduler.hh" 31 32#include "base/fiber.hh" 33#include "base/logging.hh" 34#include "sim/eventq.hh" 35#include "systemc/core/kernel.hh" 36#include "systemc/ext/core/sc_main.hh" 37 38namespace sc_gem5 39{ 40 41Scheduler::Scheduler() : 42 eq(nullptr), readyEvent(this, false, ReadyPriority), 43 pauseEvent(this, false, PausePriority), 44 stopEvent(this, false, StopPriority), 45 scMain(nullptr), 46 starvationEvent(this, false, StarvationPriority), 47 _started(false), _paused(false), _stopped(false), 48 maxTickEvent(this, false, MaxTickPriority), 49 _numCycles(0), _current(nullptr), initDone(false), 50 runOnce(false) 51{} 52 53Scheduler::~Scheduler() 54{ 55 // Clear out everything that belongs to us to make sure nobody tries to 56 // clear themselves out after the scheduler goes away. 57 clear(); 58} 59 60void 61Scheduler::clear() 62{ 63 // Delta notifications. 64 for (auto &e: deltas) 65 e->deschedule(); 66 deltas.clear(); 67 68 // Timed notifications. 69 for (auto &tsp: timeSlots) { 70 TimeSlot *&ts = tsp.second; 71 for (auto &e: ts->events) 72 e->deschedule(); 73 deschedule(ts); 74 } 75 timeSlots.clear(); 76 77 // gem5 events. 78 if (readyEvent.scheduled()) 79 deschedule(&readyEvent); 80 if (pauseEvent.scheduled()) 81 deschedule(&pauseEvent); 82 if (stopEvent.scheduled()) 83 deschedule(&stopEvent); 84 if (starvationEvent.scheduled()) 85 deschedule(&starvationEvent); 86 if (maxTickEvent.scheduled()) 87 deschedule(&maxTickEvent); 88 89 Process *p; 90 while ((p = toFinalize.getNext())) 91 p->popListNode(); 92 while ((p = initList.getNext())) 93 p->popListNode(); 94 while ((p = readyList.getNext())) 95 p->popListNode(); 96 97 Channel *c; 98 while ((c = updateList.getNext())) 99 c->popListNode(); 100} 101 102void 103Scheduler::initPhase() 104{ 105 for (Process *p = toFinalize.getNext(); p; p = toFinalize.getNext()) { 106 p->finalize(); 107 p->popListNode(); 108 } 109 110 for (Process *p = initList.getNext(); p; p = initList.getNext()) { 111 p->finalize(); 112 p->popListNode(); 113 p->ready(); 114 } 115 116 update(); 117 118 for (auto &e: deltas) 119 e->run(); 120 deltas.clear(); 121 122 for (auto ets: eventsToSchedule) 123 eq->schedule(ets.first, ets.second); 124 eventsToSchedule.clear(); 125 126 if (_started) { 127 if (starved() && !runToTime) 128 scheduleStarvationEvent(); 129 kernel->status(::sc_core::SC_RUNNING); 130 } 131 132 initDone = true; 133} 134 135void 136Scheduler::reg(Process *p) 137{ 138 if (initDone) { 139 // If we're past initialization, finalize static sensitivity. 140 p->finalize(); 141 // Mark the process as ready. 142 p->ready(); 143 } else { 144 // Otherwise, record that this process should be initialized once we 145 // get there. 146 initList.pushLast(p); 147 } 148} 149 150void 151Scheduler::dontInitialize(Process *p) 152{ 153 if (initDone) { 154 // Pop this process off of the ready list. 155 p->popListNode(); 156 } else { 157 // Push this process onto the list of processes which still need 158 // their static sensitivity to be finalized. That implicitly pops it 159 // off the list of processes to be initialized/marked ready. 160 toFinalize.pushLast(p); 161 } 162} 163 164void 165Scheduler::yield() 166{ 167 _current = readyList.getNext(); 168 if (!_current) { 169 // There are no more processes, so return control to evaluate. 170 Fiber::primaryFiber()->run(); 171 } else { 172 _current->popListNode(); 173 // Switch to whatever Fiber is supposed to run this process. All 174 // Fibers which aren't running should be parked at this line. 175 _current->fiber()->run(); 176 // If the current process needs to be manually started, start it. 177 if (_current && _current->needsStart()) { 178 _current->needsStart(false); 179 _current->run(); 180 } 181 } 182 if (_current && _current->excWrapper) { 183 // Make sure this isn't a method process. 184 assert(!_current->needsStart()); 185 auto ew = _current->excWrapper; 186 _current->excWrapper = nullptr; 187 ew->throw_it(); 188 } 189} 190 191void 192Scheduler::ready(Process *p) 193{ 194 // Clump methods together to minimize context switching. 195 if (p->procKind() == ::sc_core::SC_METHOD_PROC_) 196 readyList.pushFirst(p); 197 else 198 readyList.pushLast(p); 199 200 scheduleReadyEvent(); 201} 202 203void 204Scheduler::requestUpdate(Channel *c) 205{ 206 updateList.pushLast(c); 207 scheduleReadyEvent(); 208} 209 210void 211Scheduler::scheduleReadyEvent() 212{ 213 // Schedule the evaluate and update phases. 214 if (!readyEvent.scheduled()) { 215 schedule(&readyEvent); 216 if (starvationEvent.scheduled()) 217 deschedule(&starvationEvent); 218 } 219} 220 221void 222Scheduler::scheduleStarvationEvent() 223{ 224 if (!starvationEvent.scheduled()) { 225 schedule(&starvationEvent); 226 if (readyEvent.scheduled()) 227 deschedule(&readyEvent); 228 } 229} 230 231void 232Scheduler::runReady() 233{ 234 bool empty = readyList.empty(); 235 236 // The evaluation phase. 237 do { 238 yield(); 239 } while (!readyList.empty()); 240 241 if (!empty) 242 _numCycles++; 243 244 // The update phase. 245 update(); 246 247 if (starved() && !runToTime) 248 scheduleStarvationEvent(); 249 250 // The delta phase. 251 for (auto &e: deltas) 252 e->run(); 253 deltas.clear(); 254 255 if (runOnce) 256 schedulePause(); 257} 258 259void 260Scheduler::update() 261{ 262 Channel *channel = updateList.getNext(); 263 while (channel) { 264 channel->popListNode(); 265 channel->update(); 266 channel = updateList.getNext(); 267 } 268} 269 270void 271Scheduler::pause() 272{ 273 _paused = true; 274 kernel->status(::sc_core::SC_PAUSED); 275 runOnce = false; 276 scMain->run(); 277} 278 279void 280Scheduler::stop() 281{ 282 _stopped = true; 283 kernel->stop(); 284 285 clear(); 286 287 runOnce = false; 288 scMain->run(); 289} 290 291void 292Scheduler::start(Tick max_tick, bool run_to_time) 293{ 294 // We should be running from sc_main. Keep track of that Fiber to return 295 // to later. 296 scMain = Fiber::currentFiber(); 297 298 _started = true; 299 _paused = false; 300 _stopped = false; 301 runToTime = run_to_time; 302 303 maxTick = max_tick; 304 305 if (initDone) { 306 if (starved() && !runToTime) 307 scheduleStarvationEvent(); 308 kernel->status(::sc_core::SC_RUNNING); 309 } 310 311 schedule(&maxTickEvent, maxTick); 312 313 // Return to gem5 to let it run events, etc. 314 Fiber::primaryFiber()->run(); 315 316 if (pauseEvent.scheduled()) 317 deschedule(&pauseEvent); 318 if (stopEvent.scheduled()) 319 deschedule(&stopEvent); 320 if (maxTickEvent.scheduled()) 321 deschedule(&maxTickEvent); 322 if (starvationEvent.scheduled()) 323 deschedule(&starvationEvent); 324} 325 326void 327Scheduler::oneCycle() 328{ 329 runOnce = true; 330 scheduleReadyEvent(); 331 start(::MaxTick, false); 332} 333 334void 335Scheduler::schedulePause() 336{ 337 if (pauseEvent.scheduled()) 338 return; 339 340 schedule(&pauseEvent); 341} 342 343void 344Scheduler::scheduleStop(bool finish_delta) 345{ 346 if (stopEvent.scheduled()) 347 return; 348 349 if (!finish_delta) { 350 // If we're not supposed to finish the delta cycle, flush all 351 // pending activity. 352 clear(); 353 } 354 schedule(&stopEvent); 355} 356 357Scheduler scheduler; 358 359} // namespace sc_gem5 360