QP/C++  7.4.0-rc.1
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_MEM_APP();
258 QF_INT_ENABLE(); // unconditionally enable interrupts
259
260 QP::QEvt const * const e = next->get_();
261 // NOTE QActive::get_() performs QS_MEM_APP() before return
262
263 // dispatch event (virtual call)
264 next->dispatch(e, next->getPrio());
265 #if (QF_MAX_EPOOL > 0U)
266 QP::QF::gc(e);
267 #endif
268
269 QF_INT_DISABLE(); // unconditionally disable interrupts
270 QF_MEM_SYS();
271
272 // check internal integrity (duplicate inverse storage)
275
276 if (next->getEQueue().isEmpty()) { // empty queue?
278 #ifndef Q_UNSAFE
280 #endif
281 }
282
283 if (QXK_priv_.readySet.isEmpty()) {
284 QXK_priv_.next = nullptr;
285 next = QP::QActive::registry_[0];
286 p = 0U; // no activation needed
287 }
288 else {
289 // find next highest-prio below the lock ceiling
291 if (p <= QXK_priv_.lockCeil) {
293 if (p != 0U) {
295 }
296 }
297
298 // set the next thread and ensure that it is registered
299 next = QP::QActive::registry_[p];
300 Q_ASSERT_INCRIT(520, next != nullptr);
301
302 // is next a basic thread?
303 if (next->getOsObject() == nullptr) {
304 // is the next prio. above the initial prio.?
305 if (p > QP::QActive::registry_[prio_in]->getPrio()) {
306 #if (defined QF_ON_CONTEXT_SW) || (defined Q_SPY)
307 if (p != QXK_priv_.actPrio) { // changing threads?
308 QXK_contextSw_(next);
309 }
310 #endif // QF_ON_CONTEXT_SW || Q_SPY
311 QXK_priv_.next = next;
312 }
313 else {
314 QXK_priv_.next = nullptr;
315 p = 0U; // no activation needed
316 }
317 }
318 else { // next is the extended-thread
319 QXK_priv_.next = next;
321 p = 0U; // no activation needed
322 }
323 }
324 } while (p != 0U); // while activation needed
325
326 // restore the active prio.
327 QXK_priv_.actPrio = prio_in;
328
329 #if (defined QF_ON_CONTEXT_SW) || (defined Q_SPY)
330 if (next->getOsObject() == nullptr) {
331 QXK_contextSw_((prio_in == 0U)
332 ? nullptr
333 : QP::QActive::registry_[prio_in]);
334 }
335 #endif // QF_ON_CONTEXT_SW || Q_SPY
336}
337
338//${QXK-extern-C::QXK_contextSw_} ............................................
339void QXK_contextSw_(QP::QActive * const next) {
340 #ifdef Q_SPY
341 std::uint_fast8_t const prev_prio = (QXK_priv_.prev != nullptr)
343 : 0U;
344 if (next != nullptr) { // next is NOT idle?
345 std::uint_fast8_t const next_prio = next->getPrio();
346 QS_BEGIN_PRE_(QP::QS_SCHED_NEXT, next_prio)
347 QS_TIME_PRE_(); // timestamp
348 QS_2U8_PRE_(next_prio, prev_prio);
349 QS_END_PRE_()
350 }
351 else { // going to idle
352 QS_BEGIN_PRE_(QP::QS_SCHED_IDLE, prev_prio)
353 QS_TIME_PRE_(); // timestamp
354 QS_U8_PRE_(prev_prio);
355 QS_END_PRE_()
356 }
357 #endif // Q_SPY
358
359 #ifdef QF_ON_CONTEXT_SW
361 #endif // QF_ON_CONTEXT_SW
362
363 QXK_priv_.prev = next; // update the previous thread
364}
365
366//${QXK-extern-C::QXK_threadExit_} ...........................................
370
371 QP::QXThread const * const thr = QXTHREAD_CAST_(QXK_priv_.curr);
372
374 && (thr != nullptr)); // current thread must be extended
376
377 std::uint_fast8_t const p =
378 static_cast<std::uint_fast8_t>(thr->getPrio());
379
380 QF_MEM_SYS();
381 QP::QActive::registry_[p] = nullptr;
383 #ifndef Q_UNSAFE
385 #endif
386
387 static_cast<void>(QXK_sched_()); // schedule other threads
388
389 QF_MEM_APP();
390 QF_CRIT_EXIT();
391}
392//$enddef${QXK-extern-C} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
393} // extern "C"
394
395//$define${QXK::QF-cust} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
396namespace QP {
397namespace QF {
398
399//${QXK::QF-cust::init} ......................................................
400void init() {
401 bzero_(&QF::priv_, sizeof(QF::priv_));
402 bzero_(&QXK_priv_, sizeof(QXK_priv_));
404
405 #ifndef Q_UNSAFE
407 #endif
408
409 // setup the QXK scheduler as initially locked and not running
410 QXK_priv_.lockCeil = (QF_MAX_ACTIVE + 1U); // scheduler locked
411
412 // storage capable for holding a blank QActive object (const in ROM)
413 static void* const
414 idle_ao[((sizeof(QActive) + sizeof(void*)) - 1U) / sizeof(void*)]
415 = { nullptr };
416
417 // register the idle AO object (cast 'const' away)
419 reinterpret_cast<QActive const*>(idle_ao));
420
421 #ifdef QXK_INIT
422 QXK_INIT(); // port-specific initialization of the QXK kernel
423 #endif
424}
425
426//${QXK::QF-cust::stop} ......................................................
427void stop() {
428 onCleanup(); // cleanup callback
429 // nothing else to do for the QXK preemptive kernel
430}
431
432//${QXK::QF-cust::run} .......................................................
433int_t run() {
434 #ifdef Q_SPY
437
438 // produce the QS_QF_RUN trace record
440 QF_MEM_SYS();
441 QS::beginRec_(QS_REC_NUM_(QS_QF_RUN));
442 QS::endRec_();
443 QF_MEM_APP();
445 #endif // Q_SPY
446
447 onStartup(); // application-specific startup callback
448
450 QF_MEM_SYS();
451
452 #ifdef QXK_START
453 QXK_START(); // port-specific startup of the QXK kernel
454 #endif
455
456 QXK_priv_.lockCeil = 0U; // unlock the QXK scheduler
457
458 // activate AOs to process events posted so far
459 if (QXK_sched_() != 0U) {
461 }
462
463 QF_MEM_APP();
465
466 for (;;) { // QXK idle loop...
467 QXK::onIdle(); // application-specific QXK idle callback
468 }
469
470 #ifdef __GNUC__ // GNU compiler?
471 return 0;
472 #endif
473}
474
475} // namespace QF
476} // namespace QP
477//$enddef${QXK::QF-cust} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
478
479//$define${QXK::QActive} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
480namespace QP {
481
482//${QXK::QActive} ............................................................
483
484//${QXK::QActive::start} .....................................................
485void QActive::start(
486 QPrioSpec const prioSpec,
487 QEvt const * * const qSto,
488 std::uint_fast16_t const qLen,
489 void * const stkSto,
490 std::uint_fast16_t const stkSize,
491 void const * const par)
492{
496 && ((prioSpec & 0xFF00U) == 0U));
497 QF_CRIT_EXIT();
498
499 m_prio = static_cast<std::uint8_t>(prioSpec & 0xFFU); // QF-prio.
500 m_pthre = 0U; // not used
501 register_(); // make QF aware of this QActive/QXThread
502
503 if (stkSto == nullptr) { // starting basic thread (AO)?
504 m_eQueue.init(qSto, qLen); // init the built-in queue
505 m_osObject = nullptr; // no private stack for AO
506
507 this->init(par, m_prio); // top-most initial tran. (virtual call)
508 QS_FLUSH(); // flush the trace buffer to the host
509
510 // see if this AO needs to be scheduled if QXK is already running
512 QF_MEM_SYS();
513 if (QXK_priv_.lockCeil <= QF_MAX_ACTIVE) { // scheduler running?
514 if (QXK_sched_() != 0U) { // activation needed?
515 QXK_activate_(); // synchronously activate basic-thred(s)
516 }
517 }
518 QF_MEM_APP();
519 QF_CRIT_EXIT();
520 }
521 else { // starting QXThread
522
523 // is storage for the queue buffer provided?
524 if (qSto != nullptr) {
525 m_eQueue.init(qSto, qLen);
526 }
527
528 // extended threads provide their thread function in place of
529 // the top-most initial tran. 'm_temp.act'
530 QXK_PTR_CAST_(QXThread*, this)->stackInit_(m_temp.thr,
531 stkSto, stkSize);
532
533 // the new thread is not blocked on any object
534 m_temp.obj = nullptr;
535
537 QF_MEM_SYS();
538
539 // extended-thread becomes ready immediately
540 QXK_priv_.readySet.insert(static_cast<std::uint_fast8_t>(m_prio));
541 #ifndef Q_UNSAFE
543 #endif
544
545 // see if this thread needs to be scheduled in case QXK is running
547 static_cast<void>(QXK_sched_()); // schedule other threads
548 }
549 QF_MEM_APP();
550 QF_CRIT_EXIT();
551 }
552}
553
554} // namespace QP
555//$enddef${QXK::QActive} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Active object class (based on the QHsm implementation strategy)
Definition qp.hpp:722
QACTIVE_OS_OBJ_TYPE const & getOsObject() const noexcept
Definition qp.hpp:867
void init(void const *const e, std::uint_fast8_t const qsId) override
Definition qp.hpp:779
static QActive * registry_[QF_MAX_ACTIVE+1U]
Definition qp.hpp:748
void register_() noexcept
Definition qf_qact.cpp:76
void dispatch(QEvt const *const e, std::uint_fast8_t const qsId) override
Definition qp.hpp:788
QACTIVE_EQUEUE_TYPE m_eQueue
Definition qp.hpp:736
QEvt const * get_() noexcept
Definition qf_actq.cpp:330
std::uint8_t m_pthre
Definition qp.hpp:725
std::uint_fast8_t getPrio() const noexcept
Definition qp.hpp:849
QACTIVE_EQUEUE_TYPE const & getEQueue() const noexcept
Definition qp.hpp:861
QACTIVE_OS_OBJ_TYPE m_osObject
Definition qp.hpp:732
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:449
std::uint8_t m_prio
Definition qp.hpp:724
friend class QXThread
Definition qp.hpp:755
QAsmAttr m_temp
Definition qp.hpp:221
Event class.
Definition qp.hpp:137
std::uint_fast8_t findMax() const noexcept
Definition qp.hpp:668
void remove(std::uint_fast8_t const n) noexcept
Definition qp.hpp:656
bool verify_(QPSet const *const dis) const noexcept
Definition qp.hpp:688
bool hasElement(std::uint_fast8_t const n) const noexcept
Definition qp.hpp:635
void update_(QPSet *const dis) const noexcept
Definition qp.hpp:679
bool isEmpty() const noexcept
Definition qp.hpp:621
void insert(std::uint_fast8_t const n) noexcept
Definition qp.hpp:644
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::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
QP::QPSet readySet_dis
Definition qxk.hpp:195
void onCleanup()
void gc(QEvt const *const e) noexcept
Definition qf_dyn.cpp:222
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:369
int_t run()
Definition qk.cpp:397
void stop()
Definition qk.cpp:391
void onStartup()
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:572
@ 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:103
#define QF_MEM_APP()
Definition qp.hpp:1331
void QF_onContextSw(QP::QActive *prev, QP::QActive *next)
#define QF_MEM_SYS()
Definition qp.hpp:1326
#define QF_MAX_ACTIVE
Maximum # Active Objects in the system (1..64)
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 Q_INVARIANT_INCRIT(id_, expr_)
Definition qsafe.h:154
#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:367
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:339
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
#define QXTHREAD_CAST_(ptr_)
Definition qxk.hpp:305
#define QXK_PTR_CAST_(type_, ptr_)
Definition qxk.hpp:308
QMState const * obj
Definition qp.hpp:206
QXThreadHandler thr
Definition qp.hpp:205