QP/C++  7.3.3
Real-Time Embedded Framework
Loading...
Searching...
No Matches
qxk.cpp
Go to the documentation of this file.
1//$file${src::qxk::qxk.cpp} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
2//
3// Model: qpcpp.qm
4// File: ${src::qxk::qxk.cpp}
5//
6// This code has been generated by QM 6.1.1 <www.state-machine.com/qm>.
7// DO NOT EDIT THIS FILE MANUALLY. All your changes will be lost.
8//
9// This code is covered by the following QP license:
10// License # : LicenseRef-QL-dual
11// Issued to : Any user of the QP/C++ real-time embedded framework
12// Framework(s) : qpcpp
13// Support ends : 2024-12-31
14// License scope:
15//
16// Copyright (C) 2005 Quantum Leaps, LLC <state-machine.com>.
17//
18// Q u a n t u m L e a P s
19// ------------------------
20// Modern Embedded Software
21//
22// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-QL-commercial
23//
24// This software is dual-licensed under the terms of the open source GNU
25// General Public License version 3 (or any later version), or alternatively,
26// under the terms of one of the closed source Quantum Leaps commercial
27// licenses.
28//
29// The terms of the open source GNU General Public License version 3
30// can be found at: <www.gnu.org/licenses/gpl-3.0>
31//
32// The terms of the closed source Quantum Leaps commercial licenses
33// can be found at: <www.state-machine.com/licensing>
34//
35// Redistributions in source code must retain this top-level comment block.
36// Plagiarizing this software to sidestep the license obligations is illegal.
37//
38// Contact information:
39// <www.state-machine.com/licensing>
40// <info@state-machine.com>
41//
42//$endhead${src::qxk::qxk.cpp} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
43#define QP_IMPL // this is QP implementation
44#include "qp_port.hpp" // QP port
45#include "qp_pkg.hpp" // QP package-scope interface
46#include "qsafe.h" // QP Functional Safety (FuSa) Subsystem
47#ifdef Q_SPY // QS software tracing enabled?
48 #include "qs_port.hpp" // QS port
49 #include "qs_pkg.hpp" // QS facilities for pre-defined trace records
50#else
51 #include "qs_dummy.hpp" // disable the QS software tracing
52#endif // Q_SPY
53
54// protection against including this source file in a wrong project
55#ifndef QXK_HPP_
56 #error "Source file included in a project NOT based on the QXK kernel"
57#endif // QXK_HPP_
58
59// unnamed namespace for local definitions with internal linkage
60namespace {
61Q_DEFINE_THIS_MODULE("qxk")
62} // unnamed namespace
63
64//$skip${QP_VERSION} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
65// Check for the minimum required QP version
66#if (QP_VERSION < 730U) || (QP_VERSION != ((QP_RELEASE^4294967295U) % 0x3E8U))
67#error qpcpp version 7.3.0 or higher required
68#endif
69//$endskip${QP_VERSION} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
70
71//$define${QXK::QXK-base} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
72namespace QP {
73namespace QXK {
74
75//${QXK::QXK-base::schedLock} ................................................
76QSchedStatus schedLock(std::uint_fast8_t const ceiling) noexcept {
79 QF_MEM_SYS();
80
82
83 QSchedStatus stat; // saved lock status to be returned
84
85 // is the lock ceiling being raised?
86 if (ceiling > QXK_priv_.lockCeil) {
87 QS_BEGIN_PRE_(QS_SCHED_LOCK, 0U)
88 QS_TIME_PRE_(); // timestamp
89 // the previous lock ceiling & new lock ceiling
90 QS_2U8_PRE_(static_cast<std::uint8_t>(QXK_priv_.lockCeil),
91 static_cast<std::uint8_t>(ceiling));
92 QS_END_PRE_()
93
94 // previous status of the lock
95 stat = static_cast<QSchedStatus>(QXK_priv_.lockHolder);
96 stat |= static_cast<QSchedStatus>(QXK_priv_.lockCeil) << 8U;
97
98 // new status of the lock
99 QXK_priv_.lockHolder = (QXK_priv_.curr != nullptr)
101 : 0U;
102 QXK_priv_.lockCeil = ceiling;
103 }
104 else {
105 stat = 0xFFU; // scheduler not locked
106 }
107 QF_MEM_APP();
108 QF_CRIT_EXIT();
109
110 return stat; // return the status to be saved in a stack variable
111}
112
113//${QXK::QXK-base::schedUnlock} ..............................................
114void schedUnlock(QSchedStatus const stat) noexcept {
115 // has the scheduler been actually locked by the last QXK::schedLock()?
116 if (stat != 0xFFU) {
117 std::uint8_t const prevCeil = static_cast<std::uint8_t>(stat >> 8U);
120 QF_MEM_SYS();
121
123 Q_REQUIRE_INCRIT(201, QXK_priv_.lockCeil > prevCeil);
124
125 QS_BEGIN_PRE_(QS_SCHED_UNLOCK, 0U)
126 QS_TIME_PRE_(); // timestamp
127 // ceiling before unlocking & prio after unlocking
128 QS_2U8_PRE_(QXK_priv_.lockCeil, prevCeil);
129 QS_END_PRE_()
130
131 // restore the previous lock ceiling and lock holder
132 QXK_priv_.lockCeil = prevCeil;
133 QXK_priv_.lockHolder = (stat & 0xFFU);
134
135 // find if any threads should be run after unlocking the scheduler
136 if (QXK_sched_() != 0U) { // activation needed?
137 QXK_activate_(); // synchronously activate basic-thred(s)
138 }
139
140 QF_MEM_APP();
141 QF_CRIT_EXIT();
142 }
143}
144
145//${QXK::QXK-base::current} ..................................................
146QP::QActive * current() noexcept {
149 QF_MEM_SYS();
150
152
153 QP::QActive *curr = QXK_priv_.curr;
154 if (curr == nullptr) { // basic thread?
156 }
157
158 Q_ASSERT_INCRIT(690, curr != nullptr);
159
160 QF_MEM_APP();
161 QF_CRIT_EXIT();
162
163 return curr;
164}
165
166} // namespace QXK
167} // namespace QP
168//$enddef${QXK::QXK-base} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
169
170extern "C" {
171//$define${QXK-extern-C} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
172
173//${QXK-extern-C::QXK_priv_} .................................................
175
176//${QXK-extern-C::QXK_sched_} ................................................
177std::uint_fast8_t QXK_sched_() noexcept {
180
181 std::uint_fast8_t p;
182 if (QXK_priv_.readySet.isEmpty()) {
183 p = 0U; // no activation needed
184 }
185 else {
186 // find the highest-prio thread ready to run
188 if (p <= QXK_priv_.lockCeil) {
189 // prio. of the thread holding the lock
190 p = static_cast<std::uint_fast8_t>(
192 if (p != 0U) {
194 }
195 }
196 }
197 QP::QActive const * const curr = QXK_priv_.curr;
198 QP::QActive * const next = QP::QActive::registry_[p];
199
200 // the next thread found must be registered in QF
201 Q_ASSERT_INCRIT(420, next != nullptr);
202
203 // is the current thread a basic-thread?
204 if (curr == nullptr) {
205
206 // is the new prio. above the active prio.?
207 if (p > QXK_priv_.actPrio) {
208 QXK_priv_.next = next; // set the next AO to activate
209
210 if (next->getOsObject() != nullptr) { // is next extended?
212 p = 0U; // no activation needed
213 }
214 }
215 else { // below the active prio.
216 QXK_priv_.next = nullptr;
217 p = 0U; // no activation needed
218 }
219 }
220 else { // currently executing an extended-thread
221 // is the current thread different from the next?
222 if (curr != next) {
223 QXK_priv_.next = next;
225 }
226 else { // current is the same as next
227 QXK_priv_.next = nullptr; // no need to context-switch
228 }
229 p = 0U; // no activation needed
230 }
231
232 return p;
233}
234
235//${QXK-extern-C::QXK_activate_} .............................................
236void QXK_activate_() noexcept {
237 std::uint_fast8_t const prio_in = QXK_priv_.actPrio;
238 QP::QActive *next = QXK_priv_.next; // the next AO (basic-thread) to run
239
240 Q_REQUIRE_INCRIT(500, (next != nullptr) && (prio_in <= QF_MAX_ACTIVE));
241
242 // QXK Context switch callback defined or QS tracing enabled?
243 #if (defined QF_ON_CONTEXT_SW) || (defined Q_SPY)
244 QXK_contextSw_(next);
245 #endif // QF_ON_CONTEXT_SW || Q_SPY
246
247 QXK_priv_.next = nullptr; // clear the next AO
248 QXK_priv_.curr = nullptr; // current is basic-thread
249
250 // prio. of the next thread
251 std::uint_fast8_t p = next->getPrio();
252
253 // loop until no more ready-to-run AOs of higher prio than the initial
254 do {
255 QXK_priv_.actPrio = p; // next active prio
256
257 QF_INT_ENABLE(); // unconditionally enable interrupts
258
259 QP::QEvt const * const e = next->get_();
260 // NOTE QActive::get_() performs QS_MEM_APP() before return
261
262 // dispatch event (virtual call)
263 next->dispatch(e, next->getPrio());
264 #if (QF_MAX_EPOOL > 0U)
265 QP::QF::gc(e);
266 #endif
267
268 QF_INT_DISABLE(); // unconditionally disable interrupts
269 QF_MEM_SYS();
270
271 // check internal integrity (duplicate inverse storage)
272 Q_ASSERT_INCRIT(502,
274
275 if (next->getEQueue().isEmpty()) { // empty queue?
277 #ifndef Q_UNSAFE
279 #endif
280 }
281
282 if (QXK_priv_.readySet.isEmpty()) {
283 QXK_priv_.next = nullptr;
284 next = QP::QActive::registry_[0];
285 p = 0U; // no activation needed
286 }
287 else {
288 // find next highest-prio below the lock ceiling
290 if (p <= QXK_priv_.lockCeil) {
292 if (p != 0U) {
294 }
295 }
296
297 // set the next thread and ensure that it is registered
298 next = QP::QActive::registry_[p];
299 Q_ASSERT_INCRIT(520, next != nullptr);
300
301 // is next a basic thread?
302 if (next->getOsObject() == nullptr) {
303 // is the next prio. above the initial prio.?
304 if (p > QP::QActive::registry_[prio_in]->getPrio()) {
305 #if (defined QF_ON_CONTEXT_SW) || (defined Q_SPY)
306 if (p != QXK_priv_.actPrio) { // changing threads?
307 QXK_contextSw_(next);
308 }
309 #endif // QF_ON_CONTEXT_SW || Q_SPY
310 QXK_priv_.next = next;
311 }
312 else {
313 QXK_priv_.next = nullptr;
314 p = 0U; // no activation needed
315 }
316 }
317 else { // next is the extended-thread
318 QXK_priv_.next = next;
320 p = 0U; // no activation needed
321 }
322 }
323 } while (p != 0U); // while activation needed
324
325 // restore the active prio.
326 QXK_priv_.actPrio = prio_in;
327
328 #if (defined QF_ON_CONTEXT_SW) || (defined Q_SPY)
329 if (next->getOsObject() == nullptr) {
330 QXK_contextSw_((prio_in == 0U)
331 ? nullptr
332 : QP::QActive::registry_[prio_in]);
333 }
334 #endif // QF_ON_CONTEXT_SW || Q_SPY
335}
336
337//${QXK-extern-C::QXK_contextSw_} ............................................
338void QXK_contextSw_(QP::QActive * const next) {
339 #ifdef Q_SPY
340 std::uint_fast8_t const prev_prio = (QXK_priv_.prev != nullptr)
342 : 0U;
343 if (next != nullptr) { // next is NOT idle?
344 std::uint_fast8_t const next_prio = next->getPrio();
345 QS_BEGIN_PRE_(QP::QS_SCHED_NEXT, next_prio)
346 QS_TIME_PRE_(); // timestamp
347 QS_2U8_PRE_(next_prio, prev_prio);
348 QS_END_PRE_()
349 }
350 else { // going to idle
351 QS_BEGIN_PRE_(QP::QS_SCHED_IDLE, prev_prio)
352 QS_TIME_PRE_(); // timestamp
353 QS_U8_PRE_(prev_prio);
354 QS_END_PRE_()
355 }
356 #endif // Q_SPY
357
358 #ifdef QF_ON_CONTEXT_SW
360 #endif // QF_ON_CONTEXT_SW
361
362 QXK_priv_.prev = next; // update the previous thread
363}
364
365//${QXK-extern-C::QXK_threadExit_} ...........................................
369
370 QP::QXThread const * const thr = QXTHREAD_CAST_(QXK_priv_.curr);
371
373 && (thr != nullptr)); // current thread must be extended
375
376 std::uint_fast8_t const p =
377 static_cast<std::uint_fast8_t>(thr->getPrio());
378
379 QF_MEM_SYS();
380 QP::QActive::registry_[p] = nullptr;
382 #ifndef Q_UNSAFE
384 #endif
385
386 static_cast<void>(QXK_sched_()); // schedule other threads
387
388 QF_MEM_APP();
389 QF_CRIT_EXIT();
390}
391//$enddef${QXK-extern-C} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
392} // extern "C"
393
394//$define${QXK::QF-cust} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
395namespace QP {
396namespace QF {
397
398//${QXK::QF-cust::init} ......................................................
399void init() {
400 bzero_(&QF::priv_, sizeof(QF::priv_));
401 bzero_(&QXK_priv_, sizeof(QXK_priv_));
403
404 #ifndef Q_UNSAFE
406 #endif
407
408 // setup the QXK scheduler as initially locked and not running
409 QXK_priv_.lockCeil = (QF_MAX_ACTIVE + 1U); // scheduler locked
410
411 // storage capable for holding a blank QActive object (const in ROM)
412 static void* const
413 idle_ao[((sizeof(QActive) + sizeof(void*)) - 1U) / sizeof(void*)]
414 = { nullptr };
415
416 // register the idle AO object (cast 'const' away)
418 reinterpret_cast<QActive const*>(idle_ao));
419
420 #ifdef QXK_INIT
421 QXK_INIT(); // port-specific initialization of the QXK kernel
422 #endif
423}
424
425//${QXK::QF-cust::stop} ......................................................
426void stop() {
427 onCleanup(); // cleanup callback
428 // nothing else to do for the QXK preemptive kernel
429}
430
431//${QXK::QF-cust::run} .......................................................
432int_t run() {
433 #ifdef Q_SPY
436
437 // produce the QS_QF_RUN trace record
439 QF_MEM_SYS();
440 QS::beginRec_(QS_REC_NUM_(QS_QF_RUN));
441 QS::endRec_();
442 QF_MEM_APP();
444 #endif // Q_SPY
445
446 onStartup(); // application-specific startup callback
447
449 QF_MEM_SYS();
450
451 #ifdef QXK_START
452 QXK_START(); // port-specific startup of the QXK kernel
453 #endif
454
455 QXK_priv_.lockCeil = 0U; // unlock the QXK scheduler
456
457 // activate AOs to process events posted so far
458 if (QXK_sched_() != 0U) {
460 }
461
462 QF_MEM_APP();
464
465 for (;;) { // QXK idle loop...
466 QXK::onIdle(); // application-specific QXK idle callback
467 }
468
469 #ifdef __GNUC__ // GNU compiler?
470 return 0;
471 #endif
472}
473
474} // namespace QF
475} // namespace QP
476//$enddef${QXK::QF-cust} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
477
478//$define${QXK::QActive} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
479namespace QP {
480
481//${QXK::QActive} ............................................................
482
483//${QXK::QActive::start} .....................................................
484void QActive::start(
485 QPrioSpec const prioSpec,
486 QEvt const * * const qSto,
487 std::uint_fast16_t const qLen,
488 void * const stkSto,
489 std::uint_fast16_t const stkSize,
490 void const * const par)
491{
495 && ((prioSpec & 0xFF00U) == 0U));
496 QF_CRIT_EXIT();
497
498 m_prio = static_cast<std::uint8_t>(prioSpec & 0xFFU); // QF-prio.
499 m_pthre = 0U; // not used
500 register_(); // make QF aware of this QActive/QXThread
501
502 if (stkSto == nullptr) { // starting basic thread (AO)?
503 m_eQueue.init(qSto, qLen); // init the built-in queue
504 m_osObject = nullptr; // no private stack for AO
505
506 this->init(par, m_prio); // top-most initial tran. (virtual call)
507 QS_FLUSH(); // flush the trace buffer to the host
508
509 // see if this AO needs to be scheduled if QXK is already running
511 QF_MEM_SYS();
512 if (QXK_priv_.lockCeil <= QF_MAX_ACTIVE) { // scheduler running?
513 if (QXK_sched_() != 0U) { // activation needed?
514 QXK_activate_(); // synchronously activate basic-thred(s)
515 }
516 }
517 QF_MEM_APP();
518 QF_CRIT_EXIT();
519 }
520 else { // starting QXThread
521
522 // is storage for the queue buffer provided?
523 if (qSto != nullptr) {
524 m_eQueue.init(qSto, qLen);
525 }
526
527 // extended threads provide their thread function in place of
528 // the top-most initial tran. 'm_temp.act'
529 QXK_PTR_CAST_(QXThread*, this)->stackInit_(m_temp.thr,
530 stkSto, stkSize);
531
532 // the new thread is not blocked on any object
533 m_temp.obj = nullptr;
534
536 QF_MEM_SYS();
537
538 // extended-thread becomes ready immediately
539 QXK_priv_.readySet.insert(static_cast<std::uint_fast8_t>(m_prio));
540 #ifndef Q_UNSAFE
542 #endif
543
544 // see if this thread needs to be scheduled in case QXK is running
546 static_cast<void>(QXK_sched_()); // schedule other threads
547 }
548 QF_MEM_APP();
549 QF_CRIT_EXIT();
550 }
551}
552
553} // namespace QP
554//$enddef${QXK::QActive} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Active object class (based on the QHsm implementation strategy)
Definition qp.hpp:724
QACTIVE_OS_OBJ_TYPE const & getOsObject() const noexcept
Definition qp.hpp:869
void init(void const *const e, std::uint_fast8_t const qsId) override
Definition qp.hpp:781
QEvt const * get_() noexcept
Definition qf_actq.cpp:308
void dispatch(QEvt const *const e, std::uint_fast8_t const qsId) override
Definition qp.hpp:790
QACTIVE_EQUEUE_TYPE m_eQueue
Definition qp.hpp:738
std::uint8_t m_pthre
Definition qp.hpp:727
void start(QPrioSpec const prioSpec, QEvt const **const qSto, std::uint_fast16_t const qLen, void *const stkSto, std::uint_fast16_t const stkSize, void const *const par)
Definition qk.cpp:448
std::uint_fast8_t getPrio() const noexcept
Definition qp.hpp:851
static QActive * registry_[QF_MAX_ACTIVE+1U]
Definition qp.hpp:750
QACTIVE_EQUEUE_TYPE const & getEQueue() const noexcept
Definition qp.hpp:863
std::uint8_t m_prio
Definition qp.hpp:726
void register_() noexcept
Definition qf_qact.cpp:76
friend class QXThread
Definition qp.hpp:757
QACTIVE_OS_OBJ_TYPE m_osObject
Definition qp.hpp:734
QAsmAttr m_temp
Definition qp.hpp:223
Event class.
Definition qp.hpp:139
bool isEmpty() const noexcept
Definition qp.hpp:623
void update_(QPSet *const dis) const noexcept
Definition qp.hpp:681
bool verify_(QPSet const *const dis) const noexcept
Definition qp.hpp:690
void remove(std::uint_fast8_t const n) noexcept
Definition qp.hpp:658
std::uint_fast8_t findMax() const noexcept
Definition qp.hpp:670
void insert(std::uint_fast8_t const n) noexcept
Definition qp.hpp:646
bool hasElement(std::uint_fast8_t const n) const noexcept
Definition qp.hpp:637
eXtended (blocking) thread of the QXK preemptive kernel
Definition qxk.hpp:88
Private attributes of the QXK kernel.
Definition qxk.hpp:184
QP::QActive *volatile next
Definition qxk.hpp:187
QP::QActive *volatile prev
Definition qxk.hpp:188
std::uint_fast8_t volatile lockCeil
Definition qxk.hpp:190
QP::QPSet readySet_dis
Definition qxk.hpp:195
QP::QActive *volatile curr
Definition qxk.hpp:186
std::uint_fast8_t volatile actPrio
Definition qxk.hpp:189
std::uint_fast8_t volatile lockHolder
Definition qxk.hpp:191
QP::QPSet readySet
Definition qxk.hpp:192
void onStartup()
int_t run()
Definition qk.cpp:396
void onCleanup()
void stop()
Definition qk.cpp:390
void bzero_(void *const start, std::uint_fast16_t const len) noexcept
Definition qf_act.cpp:81
QF::Attr priv_
Definition qf_act.cpp:78
void init()
Definition qk.cpp:368
void gc(QEvt const *const e) noexcept
Definition qf_dyn.cpp:236
QSchedStatus schedLock(std::uint_fast8_t const ceiling) noexcept
Definition qxk.cpp:76
QP::QActive * current() noexcept
Definition qxk.cpp:146
@ TIMEOUT_SIG
Definition qxk.hpp:335
@ DELAY_SIG
Definition qxk.hpp:334
void schedUnlock(QSchedStatus const stat) noexcept
Definition qxk.cpp:114
void onIdle()
QP/C++ framework.
Definition qequeue.hpp:50
std::uint_fast8_t QSchedStatus
Definition qk.hpp:50
std::uint16_t QPrioSpec
Definition qp.hpp:574
@ QS_SCHED_LOCK
scheduler was locked
Definition qs.hpp:145
@ QS_QF_RUN
QF_run() was entered.
Definition qs.hpp:171
@ QS_SCHED_NEXT
scheduler started next task
Definition qs.hpp:147
@ QS_SCHED_UNLOCK
scheduler was unlocked
Definition qs.hpp:146
@ QS_SCHED_IDLE
scheduler restored the idle task
Definition qs.hpp:148
int int_t
Definition qp.hpp:105
#define QF_MEM_APP()
Definition qp.hpp:1276
void QF_onContextSw(QP::QActive *prev, QP::QActive *next)
#define QF_MEM_SYS()
Definition qp.hpp:1271
#define QF_MAX_ACTIVE
Internal (package scope) QP/C++ interface.
#define QF_CONST_CAST_(type_, ptr_)
Definition qp_pkg.hpp:79
Sample QP/C++ port.
#define QXK_ISR_CONTEXT_()
Check if the code executes in the ISR context.
Definition qp_port.hpp:137
#define QXK_CONTEXT_SWITCH_()
Trigger context switch (used internally in QXK only)
Definition qp_port.hpp:140
#define QF_INT_DISABLE()
Disable interrupts.
Definition qp_port.hpp:36
#define QF_INT_ENABLE()
Enable interrupts.
Definition qp_port.hpp:39
#define QS_TIME_PRE_()
Definition qs.hpp:473
#define QS_SIG_DICTIONARY(sig_, obj_)
Definition qs.hpp:534
#define QS_FLUSH()
Definition qs.hpp:363
QS/C++ package-scope interface.
QS/C++ port to a 32-bit CPU, generic C++ compiler.
QP Functional Safety (FuSa) Subsystem.
#define QF_CRIT_ENTRY()
Definition qsafe.h:58
#define Q_ASSERT_INCRIT(id_, expr_)
Definition qsafe.h:72
#define QF_CRIT_EXIT()
Definition qsafe.h:62
#define Q_REQUIRE_INCRIT(id_, expr_)
Definition qsafe.h:136
#define QF_CRIT_STAT
Definition qsafe.h:54
void QXK_threadExit_()
Definition qxk.cpp:366
std::uint_fast8_t QXK_sched_() noexcept
Definition qxk.cpp:177
void QXK_activate_() noexcept
Definition qxk.cpp:236
QXK_Attr QXK_priv_
Definition qxk.cpp:174
void QXK_contextSw_(QP::QActive *const next)
Definition qxk.cpp:338
void QXK_activate_() noexcept
Definition qxk.cpp:236
QXK_Attr QXK_priv_
Definition qxk.cpp:174
#define QXTHREAD_CAST_(ptr_)
Definition qxk.hpp:305
#define QXK_PTR_CAST_(type_, ptr_)
Definition qxk.hpp:308
std::uint_fast8_t QXK_sched_() noexcept
Definition qxk.cpp:177
QMState const * obj
Definition qp.hpp:208
QXThreadHandler thr
Definition qp.hpp:207