process.cc revision 13260:4d18f1d20093 
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/process.hh"
31
32#include "base/logging.hh"
33#include "systemc/core/event.hh"
34#include "systemc/core/scheduler.hh"
35#include "systemc/ext/core/sc_join.hh"
36#include "systemc/ext/core/sc_main.hh"
37#include "systemc/ext/core/sc_process_handle.hh"
38#include "systemc/ext/utils/sc_report_handler.hh"
39
40namespace sc_gem5
41{
42
43class UnwindExceptionReset : public ::sc_core::sc_unwind_exception
44{
45  public:
46    UnwindExceptionReset() { _isReset = true; }
47};
48
49class UnwindExceptionKill : public ::sc_core::sc_unwind_exception
50{
51  public:
52    UnwindExceptionKill() {}
53};
54
55template <typename T>
56struct BuiltinExceptionWrapper : public ExceptionWrapperBase
57{
58  public:
59    T t;
60    void throw_it() override { throw t; }
61};
62
63BuiltinExceptionWrapper<UnwindExceptionReset> resetException;
64BuiltinExceptionWrapper<UnwindExceptionKill> killException;
65
66
67void
68Process::forEachKid(const std::function<void(Process *)> &work)
69{
70    for (auto &kid: get_child_objects()) {
71        Process *p_kid = dynamic_cast<Process *>(kid);
72        if (p_kid)
73            work(p_kid);
74    }
75}
76
77void
78Process::suspend(bool inc_kids)
79{
80    if (inc_kids)
81        forEachKid([](Process *p) { p->suspend(true); });
82
83    if (!_suspended) {
84        _suspended = true;
85        _suspendedReady = scheduler.suspend(this);
86
87        if (procKind() != ::sc_core::SC_METHOD_PROC_ &&
88                scheduler.current() == this) {
89            // This isn't in the spec, but Accellera says that a thread that
90            // self suspends should be marked ready immediately when it's
91            // resumed.
92            _suspendedReady = true;
93            scheduler.yield();
94        }
95    }
96}
97
98void
99Process::resume(bool inc_kids)
100{
101    if (inc_kids)
102        forEachKid([](Process *p) { p->resume(true); });
103
104    if (_suspended) {
105        _suspended = false;
106        if (_suspendedReady)
107            scheduler.resume(this);
108        _suspendedReady = false;
109    }
110}
111
112void
113Process::disable(bool inc_kids)
114{
115    if (inc_kids)
116        forEachKid([](Process *p) { p->disable(true); });
117
118    if (!::sc_core::sc_allow_process_control_corners &&
119            timeoutEvent.scheduled()) {
120        std::string message("attempt to disable a thread with timeout wait: ");
121        message += name();
122        SC_REPORT_ERROR("Undefined process control interaction",
123                message.c_str());
124    }
125
126    _disabled = true;
127}
128
129void
130Process::enable(bool inc_kids)
131{
132
133    if (inc_kids)
134        forEachKid([](Process *p) { p->enable(true); });
135
136    _disabled = false;
137}
138
139void
140Process::kill(bool inc_kids)
141{
142    if (::sc_core::sc_get_status() != ::sc_core::SC_RUNNING) {
143        SC_REPORT_ERROR(
144                "(E572) a process may not be killed before it is initialized",
145                name());
146    }
147
148    // Propogate the kill to our children no matter what happens to us.
149    if (inc_kids)
150        forEachKid([](Process *p) { p->kill(true); });
151
152    // If we're in the middle of unwinding, ignore the kill request.
153    if (_isUnwinding)
154        return;
155
156    // Update our state.
157    terminate();
158    _isUnwinding = true;
159
160    // Make sure this process isn't marked ready
161    popListNode();
162
163    // Inject the kill exception into this process if it's started.
164    if (!_needsStart)
165        injectException(killException);
166}
167
168void
169Process::reset(bool inc_kids)
170{
171    if (::sc_core::sc_get_status() != ::sc_core::SC_RUNNING) {
172        SC_REPORT_ERROR(
173                "(E573) a process may not be asynchronously reset while"
174                "the simulation is not running", name());
175    }
176
177    // Propogate the reset to our children no matter what happens to us.
178    if (inc_kids)
179        forEachKid([](Process *p) { p->reset(true); });
180
181    // If we're in the middle of unwinding, ignore the reset request.
182    if (_isUnwinding)
183        return;
184
185
186    if (_needsStart) {
187        scheduler.runNow(this);
188    } else {
189        _isUnwinding = true;
190        injectException(resetException);
191    }
192
193    _resetEvent.notify();
194}
195
196void
197Process::throw_it(ExceptionWrapperBase &exc, bool inc_kids)
198{
199    if (::sc_core::sc_get_status() != ::sc_core::SC_RUNNING) {
200        SC_REPORT_ERROR(
201                "(E574) throw_it not allowed unless simulation is running ",
202                name());
203    }
204
205    if (inc_kids)
206        forEachKid([&exc](Process *p) { p->throw_it(exc, true); });
207
208    // Only inject an exception into threads that have started.
209    if (!_needsStart)
210        injectException(exc);
211}
212
213void
214Process::injectException(ExceptionWrapperBase &exc)
215{
216    excWrapper = &exc;
217    scheduler.runNow(this);
218};
219
220void
221Process::syncResetOn(bool inc_kids)
222{
223    if (inc_kids)
224        forEachKid([](Process *p) { p->syncResetOn(true); });
225
226    _syncReset = true;
227}
228
229void
230Process::syncResetOff(bool inc_kids)
231{
232    if (inc_kids)
233        forEachKid([](Process *p) { p->syncResetOff(true); });
234
235    _syncReset = false;
236}
237
238void
239Process::signalReset(bool set, bool sync)
240{
241    if (set) {
242        waitCount(0);
243        if (sync) {
244            syncResetCount++;
245        } else {
246            asyncResetCount++;
247            cancelTimeout();
248            clearDynamic();
249            scheduler.runNext(this);
250        }
251    } else {
252        if (sync)
253            syncResetCount--;
254        else
255            asyncResetCount--;
256    }
257}
258
259void
260Process::run()
261{
262    bool reset;
263    do {
264        reset = false;
265        try {
266            func->call();
267        } catch(ScHalt) {
268            std::cout << "Terminating process " << name() << std::endl;
269        } catch(const ::sc_core::sc_unwind_exception &exc) {
270            reset = exc.is_reset();
271            _isUnwinding = false;
272        } catch (...) {
273            throw;
274        }
275    } while (reset);
276    needsStart(true);
277}
278
279void
280Process::addStatic(StaticSensitivity *s)
281{
282    staticSensitivities.push_back(s);
283}
284
285void
286Process::setDynamic(DynamicSensitivity *s)
287{
288    if (dynamicSensitivity) {
289        dynamicSensitivity->clear();
290        delete dynamicSensitivity;
291    }
292    dynamicSensitivity = s;
293}
294
295void
296Process::addReset(ResetSensitivity *s)
297{
298    resetSensitivities.push_back(s);
299}
300
301void
302Process::cancelTimeout()
303{
304    if (timeoutEvent.scheduled())
305        scheduler.deschedule(&timeoutEvent);
306}
307
308void
309Process::setTimeout(::sc_core::sc_time t)
310{
311    cancelTimeout();
312    scheduler.schedule(&timeoutEvent, t);
313}
314
315void
316Process::timeout()
317{
318    // A process is considered timed_out only if it was also waiting for an
319    // event but got a timeout instead.
320    _timedOut = (dynamicSensitivity != nullptr);
321
322    setDynamic(nullptr);
323    if (disabled())
324        return;
325
326    ready();
327}
328
329void
330Process::satisfySensitivity(Sensitivity *s)
331{
332    if (_waitCount) {
333        _waitCount--;
334        return;
335    }
336
337    // If there's a dynamic sensitivity and this wasn't it, ignore.
338    if ((dynamicSensitivity || timeoutEvent.scheduled()) &&
339            dynamicSensitivity != s) {
340        return;
341    }
342
343    _timedOut = false;
344    // This sensitivity should already be cleared by this point, or the event
345    // which triggered it will take care of it.
346    delete dynamicSensitivity;
347    dynamicSensitivity = nullptr;
348    cancelTimeout();
349    ready();
350}
351
352void
353Process::ready()
354{
355    if (disabled())
356        return;
357    if (suspended())
358        _suspendedReady = true;
359    else
360        scheduler.ready(this);
361}
362
363void
364Process::lastReport(::sc_core::sc_report *report)
365{
366    if (report) {
367        _lastReport = std::unique_ptr<::sc_core::sc_report>(
368                new ::sc_core::sc_report(*report));
369    } else {
370        _lastReport = nullptr;
371    }
372}
373
374::sc_core::sc_report *Process::lastReport() const { return _lastReport.get(); }
375
376Process::Process(const char *name, ProcessFuncWrapper *func, bool internal) :
377    ::sc_core::sc_process_b(name), excWrapper(nullptr),
378    timeoutEvent([this]() { this->timeout(); }),
379    func(func), _internal(internal), _timedOut(false), _dontInitialize(false),
380    _needsStart(true), _isUnwinding(false), _terminated(false),
381    _suspended(false), _disabled(false), _syncReset(false), syncResetCount(0),
382    asyncResetCount(0), _waitCount(0), refCount(0),
383    stackSize(::Fiber::DefaultStackSize), dynamicSensitivity(nullptr)
384{
385    _dynamic =
386            (::sc_core::sc_get_status() >
387             ::sc_core::SC_BEFORE_END_OF_ELABORATION);
388    _newest = this;
389}
390
391void
392Process::terminate()
393{
394    _terminated = true;
395    _suspendedReady = false;
396    _suspended = false;
397    _syncReset = false;
398    clearDynamic();
399    cancelTimeout();
400    for (auto s: staticSensitivities) {
401        s->clear();
402        delete s;
403    }
404    staticSensitivities.clear();
405
406    _terminatedEvent.notify();
407
408    for (auto jw: joinWaiters)
409        jw->signal();
410    joinWaiters.clear();
411}
412
413Process *Process::_newest;
414
415void
416throw_it_wrapper(Process *p, ExceptionWrapperBase &exc, bool inc_kids)
417{
418    p->throw_it(exc, inc_kids);
419}
420
421} // namespace sc_gem5
422