scheduler.cc revision 13403:cebee63981d3 
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/core/sc_main_fiber.hh"
37#include "systemc/ext/core/messages.hh"
38#include "systemc/ext/core/sc_main.hh"
39#include "systemc/ext/utils/sc_report.hh"
40#include "systemc/ext/utils/sc_report_handler.hh"
41#include "systemc/utils/report.hh"
42#include "systemc/utils/tracefile.hh"
43
44namespace sc_gem5
45{
46
47Scheduler::Scheduler() :
48    eq(nullptr), readyEvent(this, false, ReadyPriority),
49    pauseEvent(this, false, PausePriority),
50    stopEvent(this, false, StopPriority), _throwToScMain(nullptr),
51    starvationEvent(this, false, StarvationPriority),
52    _elaborationDone(false), _started(false), _stopNow(false),
53    _status(StatusOther), maxTickEvent(this, false, MaxTickPriority),
54    timeAdvancesEvent(this, false, TimeAdvancesPriority), _numCycles(0),
55    _changeStamp(0), _current(nullptr), initDone(false), runOnce(false)
56{}
57
58Scheduler::~Scheduler()
59{
60    // Clear out everything that belongs to us to make sure nobody tries to
61    // clear themselves out after the scheduler goes away.
62    clear();
63}
64
65void
66Scheduler::clear()
67{
68    // Delta notifications.
69    while (!deltas.empty())
70        deltas.front()->deschedule();
71
72    // Timed notifications.
73    for (auto &tsp: timeSlots) {
74        TimeSlot *&ts = tsp.second;
75        while (!ts->events.empty())
76            ts->events.front()->deschedule();
77        deschedule(ts);
78    }
79    timeSlots.clear();
80
81    // gem5 events.
82    if (readyEvent.scheduled())
83        deschedule(&readyEvent);
84    if (pauseEvent.scheduled())
85        deschedule(&pauseEvent);
86    if (stopEvent.scheduled())
87        deschedule(&stopEvent);
88    if (starvationEvent.scheduled())
89        deschedule(&starvationEvent);
90    if (maxTickEvent.scheduled())
91        deschedule(&maxTickEvent);
92    if (timeAdvancesEvent.scheduled())
93        deschedule(&timeAdvancesEvent);
94
95    Process *p;
96    while ((p = initList.getNext()))
97        p->popListNode();
98    while ((p = readyListMethods.getNext()))
99        p->popListNode();
100    while ((p = readyListThreads.getNext()))
101        p->popListNode();
102
103    Channel *c;
104    while ((c = updateList.getNext()))
105        c->popListNode();
106}
107
108void
109Scheduler::initPhase()
110{
111    for (Process *p = initList.getNext(); p; p = initList.getNext()) {
112        p->popListNode();
113
114        if (p->dontInitialize()) {
115            if (!p->hasStaticSensitivities() && !p->internal()) {
116                SC_REPORT_WARNING(sc_core::SC_ID_DISABLE_WILL_ORPHAN_PROCESS_,
117                        p->name());
118            }
119        } else {
120            p->ready();
121        }
122    }
123
124    runUpdate();
125    runDelta();
126
127    for (auto ets: eventsToSchedule)
128        eq->schedule(ets.first, ets.second);
129    eventsToSchedule.clear();
130
131    if (_started) {
132        if (!runToTime && starved())
133            scheduleStarvationEvent();
134        kernel->status(::sc_core::SC_RUNNING);
135    }
136
137    initDone = true;
138
139    status(StatusOther);
140
141    scheduleTimeAdvancesEvent();
142}
143
144void
145Scheduler::reg(Process *p)
146{
147    if (initDone) {
148        // If not marked as dontInitialize, mark as ready.
149        if (!p->dontInitialize())
150            p->ready();
151    } else {
152        // Otherwise, record that this process should be initialized once we
153        // get there.
154        initList.pushLast(p);
155    }
156}
157
158void
159Scheduler::yield()
160{
161    // Pull a process from the active list.
162    _current = getNextReady();
163    if (!_current) {
164        // There are no more processes, so return control to evaluate.
165        Fiber::primaryFiber()->run();
166    } else {
167        _current->popListNode();
168        _current->scheduled(false);
169        // Switch to whatever Fiber is supposed to run this process. All
170        // Fibers which aren't running should be parked at this line.
171        _current->fiber()->run();
172        // If the current process needs to be manually started, start it.
173        if (_current && _current->needsStart()) {
174            _current->needsStart(false);
175            // If a process hasn't started yet, "resetting" it just starts it
176            // and signals its reset event.
177            if (_current->inReset())
178                _current->resetEvent().notify();
179            try {
180                _current->run();
181            } catch (...) {
182                throwToScMain();
183            }
184        }
185    }
186    if (_current && !_current->needsStart()) {
187        if (_current->excWrapper) {
188            auto ew = _current->excWrapper;
189            _current->excWrapper = nullptr;
190            ew->throw_it();
191        } else if (_current->inReset()) {
192            _current->reset(false);
193        }
194    }
195}
196
197void
198Scheduler::ready(Process *p)
199{
200    if (_stopNow)
201        return;
202
203    p->scheduled(true);
204
205    if (p->procKind() == ::sc_core::SC_METHOD_PROC_)
206        readyListMethods.pushLast(p);
207    else
208        readyListThreads.pushLast(p);
209
210    if (!inEvaluate())
211        scheduleReadyEvent();
212}
213
214void
215Scheduler::resume(Process *p)
216{
217    if (initDone)
218        ready(p);
219    else
220        initList.pushLast(p);
221}
222
223bool
224listContains(ListNode *list, ListNode *target)
225{
226    ListNode *n = list->nextListNode;
227    while (n != list)
228        if (n == target)
229            return true;
230    return false;
231}
232
233bool
234Scheduler::suspend(Process *p)
235{
236    bool was_ready;
237    if (initDone) {
238        // After initialization, check if we're on a ready list.
239        was_ready = (p->nextListNode != nullptr);
240        p->popListNode();
241    } else {
242        // Nothing is ready before init.
243        was_ready = false;
244    }
245    return was_ready;
246}
247
248void
249Scheduler::requestUpdate(Channel *c)
250{
251    updateList.pushLast(c);
252    if (!inEvaluate())
253        scheduleReadyEvent();
254}
255
256void
257Scheduler::scheduleReadyEvent()
258{
259    // Schedule the evaluate and update phases.
260    if (!readyEvent.scheduled()) {
261        schedule(&readyEvent);
262        if (starvationEvent.scheduled())
263            deschedule(&starvationEvent);
264    }
265}
266
267void
268Scheduler::scheduleStarvationEvent()
269{
270    if (!starvationEvent.scheduled()) {
271        schedule(&starvationEvent);
272        if (readyEvent.scheduled())
273            deschedule(&readyEvent);
274    }
275}
276
277void
278Scheduler::runReady()
279{
280    scheduleTimeAdvancesEvent();
281
282    bool empty = readyListMethods.empty() && readyListThreads.empty();
283    lastReadyTick = getCurTick();
284
285    // The evaluation phase.
286    status(StatusEvaluate);
287    do {
288        yield();
289    } while (getNextReady());
290    _current = nullptr;
291
292    if (!empty) {
293        _numCycles++;
294        _changeStamp++;
295    }
296
297    if (_stopNow) {
298        status(StatusOther);
299        return;
300    }
301
302    runUpdate();
303    if (!traceFiles.empty())
304        trace(true);
305    runDelta();
306
307    if (!runToTime && starved())
308        scheduleStarvationEvent();
309
310    if (runOnce)
311        schedulePause();
312
313    status(StatusOther);
314}
315
316void
317Scheduler::runUpdate()
318{
319    status(StatusUpdate);
320
321    try {
322        Channel *channel = updateList.getNext();
323        while (channel) {
324            channel->popListNode();
325            channel->update();
326            channel = updateList.getNext();
327        }
328    } catch (...) {
329        throwToScMain();
330    }
331}
332
333void
334Scheduler::runDelta()
335{
336    status(StatusDelta);
337
338    try {
339        while (!deltas.empty())
340            deltas.back()->run();
341    } catch (...) {
342        throwToScMain();
343    }
344}
345
346void
347Scheduler::pause()
348{
349    status(StatusPaused);
350    kernel->status(::sc_core::SC_PAUSED);
351    runOnce = false;
352    if (scMainFiber.called() && !scMainFiber.finished())
353        scMainFiber.run();
354}
355
356void
357Scheduler::stop()
358{
359    status(StatusStopped);
360    kernel->stop();
361
362    clear();
363
364    runOnce = false;
365    if (scMainFiber.called() && !scMainFiber.finished())
366        scMainFiber.run();
367}
368
369void
370Scheduler::start(Tick max_tick, bool run_to_time)
371{
372    _started = true;
373    status(StatusOther);
374    runToTime = run_to_time;
375
376    maxTick = max_tick;
377    lastReadyTick = getCurTick();
378
379    if (initDone) {
380        if (!runToTime && starved())
381            scheduleStarvationEvent();
382        kernel->status(::sc_core::SC_RUNNING);
383    }
384
385    schedule(&maxTickEvent, maxTick);
386    scheduleTimeAdvancesEvent();
387
388    // Return to gem5 to let it run events, etc.
389    Fiber::primaryFiber()->run();
390
391    if (pauseEvent.scheduled())
392        deschedule(&pauseEvent);
393    if (stopEvent.scheduled())
394        deschedule(&stopEvent);
395    if (maxTickEvent.scheduled())
396        deschedule(&maxTickEvent);
397    if (starvationEvent.scheduled())
398        deschedule(&starvationEvent);
399
400    if (_throwToScMain) {
401        const ::sc_core::sc_report *to_throw = _throwToScMain;
402        _throwToScMain = nullptr;
403        throw *to_throw;
404    }
405}
406
407void
408Scheduler::oneCycle()
409{
410    runOnce = true;
411    scheduleReadyEvent();
412    start(::MaxTick, false);
413}
414
415void
416Scheduler::schedulePause()
417{
418    if (pauseEvent.scheduled())
419        return;
420
421    schedule(&pauseEvent);
422}
423
424void
425Scheduler::throwToScMain()
426{
427    ::sc_core::sc_report report = reportifyException();
428    _throwToScMain = &report;
429    status(StatusOther);
430    scMainFiber.run();
431}
432
433void
434Scheduler::scheduleStop(bool finish_delta)
435{
436    if (stopEvent.scheduled())
437        return;
438
439    if (!finish_delta) {
440        _stopNow = true;
441        // If we're not supposed to finish the delta cycle, flush all
442        // pending activity.
443        clear();
444    }
445    schedule(&stopEvent);
446}
447
448void
449Scheduler::trace(bool delta)
450{
451    for (auto tf: traceFiles)
452        tf->trace(delta);
453}
454
455Scheduler scheduler;
456Process *getCurrentProcess() { return scheduler.current(); }
457
458namespace {
459
460void
461throwingReportHandler(const ::sc_core::sc_report &r,
462                      const ::sc_core::sc_actions &)
463{
464    throw r;
465}
466
467} // anonymous namespace
468
469const ::sc_core::sc_report
470reportifyException()
471{
472    ::sc_core::sc_report_handler_proc old_handler = reportHandlerProc;
473    ::sc_core::sc_report_handler::set_handler(&throwingReportHandler);
474
475    try {
476        try {
477            // Rethrow the current exception so we can catch it and throw an
478            // sc_report instead if it's not a type we recognize/can handle.
479            throw;
480        } catch (const ::sc_core::sc_report &) {
481            // It's already a sc_report, so nothing to do.
482            throw;
483        } catch (const ::sc_core::sc_unwind_exception &) {
484            panic("Kill/reset exception escaped a Process::run()");
485        } catch (const std::exception &e) {
486            SC_REPORT_ERROR(
487                    sc_core::SC_ID_SIMULATION_UNCAUGHT_EXCEPTION_, e.what());
488        } catch (const char *msg) {
489            SC_REPORT_ERROR(
490                    sc_core::SC_ID_SIMULATION_UNCAUGHT_EXCEPTION_, msg);
491        } catch (...) {
492            SC_REPORT_ERROR(
493                    sc_core::SC_ID_SIMULATION_UNCAUGHT_EXCEPTION_,
494                    "UNKNOWN EXCEPTION");
495        }
496    } catch (const ::sc_core::sc_report &r) {
497        ::sc_core::sc_report_handler::set_handler(old_handler);
498        return r;
499    }
500    panic("No exception thrown in reportifyException.");
501}
502
503} // namespace sc_gem5
504