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
| 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 _resetEvent.notify();
187
|
186 if (_needsStart) {
187 scheduler.runNow(this);
188 } else {
189 _isUnwinding = true;
190 injectException(resetException);
191 }
| 188 if (_needsStart) {
189 scheduler.runNow(this);
190 } else {
191 _isUnwinding = true;
192 injectException(resetException);
193 }
|
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
| 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
|