/*..........................................................................*/
void QF_run(void) {
QK_INT_LOCK_KEY_
QK_INT_LOCK_();
QK_currPrio_ = (uint8_t)0; /* set the priority for the QK idle loop */
QK_SCHEDULE_(); /* process all events produced so far */
QK_INT_UNLOCK_();
QF_onStartup(); /* startup callback */
for (;;) { /* the QK idle loop */
QK_onIdle(); /* invoke the QK on-idle callback */
}
}
void QK_schedule_(void) {
#else
void QK_schedule_(QF_INT_KEY_TYPE intLockKey_) {
#endif
uint8_t p;
/* the QK scheduler must be called at task level only */
Q_REQUIRE(QK_intNest_ == (uint8_t)0);
#if (QF_MAX_ACTIVE <= 8)
if (QPSet8_notEmpty(&QK_readySet_)) {
/* determine the priority of the highest-priority task ready to run */
QPSet8_findMax(&QK_readySet_, p);
#else
if (QPSet64_notEmpty(&QK_readySet_)) {
/* determine the priority of the highest-priority task ready to run */
QPSet64_findMax(&QK_readySet_, p);
#endif
#ifdef QK_NO_MUTEX
if (p > QK_currPrio_) { /* do we have a preemption? */
#else /* QK priority-ceiling mutexes allowed */
if ((p > QK_currPrio_) && (p > QK_ceilingPrio_)) {
#endif
uint8_t pin = QK_currPrio_; /* save the initial priority */
QActive *a;
#ifdef QK_TLS /* thread-local storage used? */
uint8_t pprev = pin;
#endif
do {
QEvent const *e;
a = QF_active_[p]; /* obtain the pointer to the AO */
QK_currPrio_ = p; /* this becomes the current task priority */
#ifdef QK_TLS /* thread-local storage used? */
if (p != pprev) { /* are we changing threads? */
QK_TLS(a); /* switch new thread-local storage */
pprev = p;
}
#endif
QS_BEGIN_NOLOCK_(QS_QK_SCHEDULE, QS_aoObj_, a)
QS_TIME_(); /* timestamp */
QS_U8_(p); /* the priority of the AO */
QS_U8_(pin); /* the preempted priority */
QS_END_NOLOCK_()
QK_INT_UNLOCK_(); /* unlock the interrupts */
e = QActive_get_(a); /* get the next event for this AO */
QF_ACTIVE_DISPATCH_(&a->super, e); /* dispatch to the AO */
QF_gc(e); /* garbage collect the event, if necessary */
QK_INT_LOCK_();
/* determine the highest-priority AO ready to run */
#if (QF_MAX_ACTIVE <= 8)
if (QPSet8_notEmpty(&QK_readySet_)) {
QPSet8_findMax(&QK_readySet_, p);
#else
if (QPSet64_notEmpty(&QK_readySet_)) {
QPSet64_findMax(&QK_readySet_, p);
#endif
}
else {
p = (uint8_t)0;
}
#ifdef QK_NO_MUTEX
} while (p > pin); /* is the new priority higher than initial? */
#else /* QK priority-ceiling mutexes allowed */
} while ((p > pin) && (p > QK_ceilingPrio_));
#endif
QK_currPrio_ = pin; /* restore the initial priority */
#ifdef QK_TLS /* thread-local storage used? */
if (pin != (uint8_t)0) {/*no extended context for the idle loop */
a = QF_active_[pin]; /* the pointer to the preempted AO */
QK_TLS(a); /* restore the original TLS */
}
#endif
}
}
}
void QK_scheduleExt_(void) {
#else
void QK_scheduleExt_(QF_INT_KEY_TYPE intLockKey_) {
#endif
// the QK scheduler must be called at task level only
Q_REQUIRE(QK_intNest_ == (uint8_t)0);
// determine the priority of the highest-priority task ready to run
uint8_t p = QK_readySet_.findMax();
#ifdef QK_NO_MUTEX
if (p > QK_currPrio_) { // do we have a preemption?
#else // QK priority-ceiling mutexes allowed
if ((p > QK_currPrio_) && (p > QK_ceilingPrio_)) {
#endif
uint8_t pin = QK_currPrio_; // save the initial priority
QActive *a;
#ifdef QK_TLS // thread-local storage used?
uint8_t pprev = pin;
#endif
#ifdef QK_EXT_SAVE // extended context-switch used?
if (pin != (uint8_t)0) { // no extended context for the idle loop
a = QF::active_[pin]; // the pointer to the preempted AO
QK_EXT_SAVE(a); // save the extended context
}
#endif
do {
QEvent const *e;
a = QF::active_[p]; // obtain the pointer to the AO
QK_currPrio_ = p; // this becomes the current task priority
#ifdef QK_TLS // thread-local storage used?
if (p != pprev) { // are we changing threads?
QK_TLS(a); // switch new thread-local storage
pprev = p;
}
#endif
QS_BEGIN_NOLOCK_(QS_QK_SCHEDULE, QS::aoObj_, a)
QS_TIME_(); // timestamp
QS_U8_(p); // the priority of the active object
QS_U8_(pin); // the preempted priority
QS_END_NOLOCK_()
QK_INT_UNLOCK_(); // unlock the interrupts
e = a->get_(); // get the next event for this active object
a->dispatch(e); // dispatch e to the active object
QF::gc(e); // garbage collect the event, if necessary
QK_INT_LOCK_();
// determine the highest-priority AO ready to run
p = QK_readySet_.findMax();
#ifdef QK_NO_MUTEX
} while (p > pin); // is the new priority higher than initial?
#else // QK priority-ceiling mutexes allowed
} while ((p > pin) && (p > QK_ceilingPrio_));
#endif
QK_currPrio_ = pin; // restore the initial priority
#if defined(QK_TLS) || defined(QK_EXT_RESTORE)
if (pin != (uint8_t)0) { // no extended context for the idle loop
a = QF::active_[pin]; // the pointer to the preempted AO
#ifdef QK_TLS // thread-local storage used?
QK_TLS(a); // restore the original TLS
#endif
#ifdef QK_EXT_RESTORE // extended context-switch used?
QK_EXT_RESTORE(a); // restore the extended context
#endif
}
#endif
}
}
