void QF_tick(void) { /* see NOTE01 */
#else
void QF_tick(void const *sender) {
#endif
QTimeEvt *t;
QF_CRIT_STAT_
QF_CRIT_ENTRY_();
QS_BEGIN_NOCRIT_(QS_QF_TICK, (void *)0, (void *)0)
QS_TEC_((QTimeEvtCtr)(++QS_tickCtr_)); /* the tick counter */
QS_END_NOCRIT_()
t = QF_timeEvtListHead_;
while (t != (QTimeEvt *)0) {
--t->ctr;
if (t->ctr == (QTimeEvtCtr)0) { /* is time evt about to expire? */
if (t->interval != (QTimeEvtCtr)0) { /* is it periodic timeout? */
t->ctr = t->interval; /* rearm the time event */
}
else { /* one-shot timeout, disarm by removing it from the list */
if (t == QF_timeEvtListHead_) {
QF_timeEvtListHead_ = t->next;
}
else {
if (t->next != (QTimeEvt *)0) { /* not the last event? */
t->next->prev = t->prev;
}
t->prev->next = t->next;
}
t->prev = (QTimeEvt *)0; /* mark the event disarmed */
QS_BEGIN_NOCRIT_(QS_QF_TIMEEVT_AUTO_DISARM, QS_teObj_, t)
QS_OBJ_(t); /* this time event object */
QS_OBJ_(t->act); /* the active object */
QS_END_NOCRIT_()
}
QS_BEGIN_NOCRIT_(QS_QF_TIMEEVT_POST, QS_teObj_, t)
QS_TIME_(); /* timestamp */
QS_OBJ_(t); /* the time event object */
QS_SIG_(t->super.sig); /* signal of this time event */
QS_OBJ_(t->act); /* the active object */
QS_END_NOCRIT_()
QF_CRIT_EXIT_();/* exit crit. section before calling QF service */
/* QACTIVE_POST() asserts internally if the queue overflows */
QACTIVE_POST(t->act, &t->super, sender);
}
else {
static uint8_t volatile dummy;
QF_CRIT_EXIT_();
dummy = (uint8_t)0; /* execute a few instructions, see NOTE02 */
}
QF_CRIT_ENTRY_(); /* enter crit. section again to advance the link */
t = t->next;
}
/* NOTE: the QK scheduler is entered and exited with interrupts DISABLED */
void QK_sched_(uint8_t p) {
uint8_t pin = QK_currPrio_; /* save the initial priority */
QActive *a;
#ifdef QK_TLS /* thread-local storage used? */
uint8_t pprev = pin;
#endif
do {
QEvt 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_NOCRIT_(QS_QK_SCHEDULE, QS_priv_.aoObjFilter, a)
QS_TIME_(); /* timestamp */
QS_U8_(p); /* the priority of the AO */
QS_U8_(pin); /* the preempted priority */
QS_END_NOCRIT_()
QF_INT_ENABLE(); /* unconditionally enable interrupts */
e = QActive_get_(a); /* get the next event for this AO */
QMSM_DISPATCH(&a->super, e); /* dispatch to the AO */
QF_gc(e); /* garbage collect the event, if necessary */
QF_INT_DISABLE(); /* disable interrupts */
#if (QF_MAX_ACTIVE <= 8) /* new highest-prio AO ready to run */
QPSet8_findMax(&QK_readySet_, p);
#else
QPSet64_findMax(&QK_readySet_, p);
#endif
if (p <= pin) { /* below the current preemption threshold? */
p = (uint8_t)0;
}
#ifndef QK_NO_MUTEX
else if (p <= QK_ceilingPrio_) { /* below the mutex ceiling? */
p = (uint8_t)0;
}
else {
/* empty */
}
#endif
} while (p != (uint8_t)0);
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 QTimeEvt_arm_(QTimeEvt *me, QActive *act, QTimeEvtCtr nTicks) {
QF_CRIT_STAT_
Q_REQUIRE((nTicks > (QTimeEvtCtr)0) /* cannot arm a timer with 0 ticks */
&& (me->super.sig >= (QSignal)Q_USER_SIG) /* valid signal */
&& (me->prev == (QTimeEvt *)0) /* time evt must NOT be used */
&& (act != (QActive *)0)); /* active object must be provided */
me->ctr = nTicks;
me->prev = me; /* mark the timer in use */
me->act = act;
QF_CRIT_ENTRY_();
QS_BEGIN_NOCRIT_(QS_QF_TIMEEVT_ARM, QS_teObj_, me)
QS_TIME_(); /* timestamp */
QS_OBJ_(me); /* this time event object */
QS_OBJ_(act); /* the active object */
QS_TEC_(nTicks); /* the number of ticks */
QS_TEC_(me->interval); /* the interval */
QS_END_NOCRIT_()
me->next = QF_timeEvtListHead_;
if (QF_timeEvtListHead_ != (QTimeEvt *)0) {
QF_timeEvtListHead_->prev = me;
}
QF_timeEvtListHead_ = me;
QF_CRIT_EXIT_();
}
uint8_t QS_onStartup(void const *arg)
{
qsBuf = kmalloc(QS_SPY_SIZE, GFP_KERNEL);
if (qsBuf == NULL)
return 0;
QS_initBuf(qsBuf, QS_SPY_SIZE);
QS_FILTER_ON(QS_ALL_RECORDS);
QS_FILTER_OFF(QS_QF_TICK);
QS_BEGIN_NOCRIT_(QS_QEP_RESERVED0, (void *)0, (void *)0)
QS_U8_(QS_TIME_SIZE);
QS_U8_(QS_OBJ_PTR_SIZE);
QS_U8_(QS_FUN_PTR_SIZE);
QS_U8_(Q_SIGNAL_SIZE);
QS_U8_(QF_EQUEUE_CTR_SIZE);
QS_U8_(QF_EQUEUE_CTR_SIZE);
QS_U8_(QF_MPOOL_CTR_SIZE);
QS_U8_(QF_MPOOL_SIZ_SIZE);
QS_U8_(QF_TIMEEVT_CTR_SIZE);
QS_END_NOCRIT_();
return 1;
}
/* NOTE: disarm a timer (no harm in disarming an already disarmed timer) */
uint8_t QTimeEvt_disarm(QTimeEvt * const me) {
uint8_t wasArmed;
QF_CRIT_STAT_
QF_CRIT_ENTRY_();
if (me->ctr != (QTimeEvtCtr)0) { /* is the time evt running? */
wasArmed = (uint8_t)1;
QS_BEGIN_NOCRIT_(QS_QF_TIMEEVT_DISARM, QS_priv_.teObjFilter, me)
QS_TIME_(); /* timestamp */
QS_OBJ_(me); /* this time event object */
QS_OBJ_(me->act); /* the target AO */
QS_TEC_(me->ctr); /* the number of ticks */
QS_TEC_(me->interval); /* the interval */
QS_U8_((uint8_t)(me->super.refCtr_ & (uint8_t)0x7F));/*tick rate*/
QS_END_NOCRIT_()
me->ctr = (QTimeEvtCtr)0; /* schedule removal from the list */
}
else { /* the time event was already not running */
wasArmed = (uint8_t)0;
QS_BEGIN_NOCRIT_(QS_QF_TIMEEVT_DISARM_ATTEMPT,
QS_priv_.teObjFilter, me)
QS_TIME_(); /* timestamp */
QS_OBJ_(me); /* this time event object */
QS_OBJ_(me->act); /* the target AO */
QS_U8_((uint8_t)(me->super.refCtr_ & (uint8_t)0x7F));/*tick rate*/
QS_END_NOCRIT_()
}
QF_CRIT_EXIT_();
return wasArmed;
}
/*..........................................................................*/
void QActive_unsubscribeAll(QActive const *me) {
uint8_t p = me->prio;
uint8_t i;
QSignal sig;
Q_REQUIRE(((uint8_t)0 < p) && (p <= (uint8_t)QF_MAX_ACTIVE)
&& (QF_active_[p] == me));
i = QF_div8Lkup[p];
for (sig = (QSignal)Q_USER_SIG; sig < QF_maxSignal_; ++sig) {
QF_CRIT_STAT_
QF_CRIT_ENTRY_();
if ((QF_PTR_AT_(QF_subscrList_, sig).bits[i]
& Q_ROM_BYTE(QF_pwr2Lkup[p])) != (uint8_t)0)
{
QS_BEGIN_NOCRIT_(QS_QF_ACTIVE_UNSUBSCRIBE, QS_aoObj_, me)
QS_TIME_(); /* timestamp */
QS_SIG_(sig); /* the signal of this event */
QS_OBJ_(me); /* this active object */
QS_END_NOCRIT_()
/* clear the priority bit */
QF_PTR_AT_(QF_subscrList_, sig).bits[i] &=
Q_ROM_BYTE(QF_invPwr2Lkup[p]);
}
QF_CRIT_EXIT_();
}
}
/*..........................................................................*/
uint8_t QTimeEvt_rearm(QTimeEvt * const me, QTimeEvtCtr const nTicks) {
uint8_t isArmed;
QF_CRIT_STAT_
Q_REQUIRE((nTicks != (QTimeEvtCtr)0) /* cannot arm a timer with 0 ticks */
&& (me->act != (QActive *)0) /* active object must be valid */
&& (me->super.sig >= (QSignal)Q_USER_SIG)); /* valid signal */
QF_CRIT_ENTRY_();
if (me->ctr == (QTimeEvtCtr)0) { /* is the time evt disarmed? */
isArmed = (uint8_t)0;
if (QF_EVT_REF_CTR_(&me->super) == (uint8_t)0) { /* not linked? */
me->next = QF_timeEvtListHead_;
QF_timeEvtListHead_ = me;
QF_EVT_REF_CTR_INC_(&me->super); /* mark as linked */
}
}
else { /* the time event is armed */
isArmed = (uint8_t)1;
}
me->ctr = nTicks; /* re-load the tick counter (shift the phasing) */
QS_BEGIN_NOCRIT_(QS_QF_TIMEEVT_REARM, QS_teObj_, me)
QS_TIME_(); /* timestamp */
QS_OBJ_(me); /* this time event object */
QS_OBJ_(me->act); /* the active object */
QS_TEC_(me->ctr); /* the number of ticks */
QS_TEC_(me->interval); /* the interval */
QS_U8_(isArmed); /* was the timer armed? */
QS_END_NOCRIT_()
QF_CRIT_EXIT_();
return isArmed;
}
//****************************************************************************
/// @description
/// This function is part of the Publish-Subscribe event delivery mechanism
/// available in QF. Un-subscribing from all events means that the framework
/// will stop posting any published events to the event queue of the active
/// object.
///
/// @note Due to the latency of event queues, an active object should NOT
/// assume that no events will ever be dispatched to the state machine of
/// the active object after un-subscribing from all events.
/// The events might be already in the queue, or just about to be posted
/// and the un-subscribe operation will not flush such events. Also, the
/// alternative event-delivery mechanisms, such as direct event posting or
/// time events, can be still delivered to the event queue of the active
/// object.
///
/// @sa QP::QF::publish_(), QP::QMActive::subscribe(), and
/// QP::QMActive::unsubscribe()
///
void QMActive::unsubscribeAll(void) const {
uint_fast8_t const p = m_prio;
Q_REQUIRE_ID(500, (static_cast<uint_fast8_t>(0) < p)
&& (p <= static_cast<uint_fast8_t>(QF_MAX_ACTIVE))
&& (QF::active_[p] == this));
uint_fast8_t const i =
static_cast<uint_fast8_t>(QF_div8Lkup[p]);
enum_t sig;
for (sig = Q_USER_SIG; sig < QF_maxSignal_; ++sig) {
QF_CRIT_STAT_
QF_CRIT_ENTRY_();
if ((QF_PTR_AT_(QF_subscrList_, sig).m_bits[i]
& QF_pwr2Lkup[p]) != static_cast<uint8_t>(0))
{
QS_BEGIN_NOCRIT_(QS_QF_ACTIVE_UNSUBSCRIBE,
QS::priv_.aoObjFilter, this)
QS_TIME_(); // timestamp
QS_SIG_(sig); // the signal of this event
QS_OBJ_(this); // this active object
QS_END_NOCRIT_()
// clear the priority bit
QF_PTR_AT_(QF_subscrList_, sig).m_bits[i] &= QF_invPwr2Lkup[p];
}
QF_CRIT_EXIT_();
}
}
//****************************************************************************
/// @description
/// This function implements a simple garbage collector for dynamic events.
/// Only dynamic events are candidates for recycling. (A dynamic event is one
/// that is allocated from an event pool, which is determined as non-zero
/// e->poolId_ attribute.) Next, the function decrements the reference counter
/// of the event (e->refCtr_), and recycles the event only if the counter
/// drops to zero (meaning that no more references are outstanding for this
/// event). The dynamic event is recycled by returning it to the pool from
/// which it was originally allocated.
///
/// @param[in] e pointer to the event to recycle
///
/// @note
/// QF invokes the garbage collector at all appropriate contexts, when
/// an event can become garbage (automatic garbage collection), so the
/// application code should have no need to call QP::QF::gc() directly.
/// The QP::QF::gc() function is exposed only for special cases when your
/// application sends dynamic events to the "raw" thread-safe queues
/// (see QP::QEQueue). Such queues are processed outside of QF and the
/// automatic garbage collection is **NOT** performed for these events.
/// In this case you need to call QP::QF::gc() explicitly.
///
void QF::gc(QEvt const * const e) {
// is it a dynamic event?
if (QF_EVT_POOL_ID_(e) != static_cast<uint8_t>(0)) {
QF_CRIT_STAT_
QF_CRIT_ENTRY_();
// isn't this the last reference?
if (e->refCtr_ > static_cast<uint8_t>(1)) {
QF_EVT_REF_CTR_DEC_(e); // decrement the ref counter
QS_BEGIN_NOCRIT_(QS_QF_GC_ATTEMPT,
static_cast<void *>(0), static_cast<void *>(0))
QS_TIME_(); // timestamp
QS_SIG_(e->sig); // the signal of the event
QS_2U8_(e->poolId_, e->refCtr_);// pool Id & refCtr of the evt
QS_END_NOCRIT_()
QF_CRIT_EXIT_();
}
// this is the last reference to this event, recycle it
else {
uint_fast8_t idx = static_cast<uint_fast8_t>(e->poolId_)
- static_cast<uint_fast8_t>(1);
QS_BEGIN_NOCRIT_(QS_QF_GC,
static_cast<void *>(0), static_cast<void *>(0))
QS_TIME_(); // timestamp
QS_SIG_(e->sig); // the signal of the event
QS_2U8_(e->poolId_, e->refCtr_);// pool Id & refCtr of the evt
QS_END_NOCRIT_()
QF_CRIT_EXIT_();
// pool ID must be in range
Q_ASSERT_ID(410, idx < QF_maxPool_);
#ifdef Q_EVT_VIRTUAL
// explicitly exectute the destructor'
// NOTE: casting 'const' away is legitimate,
// because it's a pool event
QF_EVT_CONST_CAST_(e)->~QEvt(); // xtor,
#endif
// cast 'const' away, which is OK, because it's a pool event
QF_EPOOL_PUT_(QF_pool_[idx], QF_EVT_CONST_CAST_(e));
}
}
}
//............................................................................
void QF::gc(QEvt const * const e) {
if (QF_EVT_POOL_ID_(e) != u8_0) { // is it a dynamic event?
QF_CRIT_STAT_
QF_CRIT_ENTRY_();
if (QF_EVT_REF_CTR_(e) > u8_1) { // isn't this the last reference?
QF_EVT_REF_CTR_DEC_(e); // decrement the ref counter
QS_BEGIN_NOCRIT_(QS_QF_GC_ATTEMPT, null_void, null_void)
QS_TIME_(); // timestamp
QS_SIG_(e->sig); // the signal of the event
QS_U8_(QF_EVT_POOL_ID_(e)); // the pool Id of the event
QS_U8_(QF_EVT_REF_CTR_(e)); // the ref count of the event
QS_END_NOCRIT_()
QF_CRIT_EXIT_();
}
else { // this is the last reference to this event, recycle it
uint8_t idx = static_cast<uint8_t>(QF_EVT_POOL_ID_(e) - u8_1);
QS_BEGIN_NOCRIT_(QS_QF_GC, null_void, null_void)
QS_TIME_(); // timestamp
QS_SIG_(e->sig); // the signal of the event
QS_U8_(QF_EVT_POOL_ID_(e)); // the pool Id of the event
QS_U8_(QF_EVT_REF_CTR_(e)); // the ref count of the event
QS_END_NOCRIT_()
QF_CRIT_EXIT_();
Q_ASSERT(idx < QF_maxPool_);
#ifdef Q_EVT_VIRTUAL
QF_EVT_CONST_CAST_(e)->~QEvt(); // xtor, cast 'const' away,
// which is legitimate, because it's a pool event
#endif
// cast 'const' away, which is OK, because it's a pool event
QF_EPOOL_PUT_(QF_pool_[idx], QF_EVT_CONST_CAST_(e));
}
}
}
/**
* \description
* Arms a time event to fire in a specified number of clock ticks and with
* a specified interval. If the interval is zero, the time event is armed for
* one shot ('one-shot' time event). The time event gets directly posted
* (using the FIFO policy) into the event queue of the host active object.
*
* \arguments
* \arg[in,out] \c me pointer (see \ref derivation)
* \arg[in] \c nTicks number of clock ticks (at the associated rate)
* to rearm the time event with.
* \arg[in] \c interval interval (in clock ticks) for periodic time event.
*
* \note After posting, a one-shot time event gets automatically disarmed
* while a periodic time event (interval != 0) is automatically re-armed.
*
* \note A time event can be disarmed at any time by calling the
* QTimeEvt_disarm() function. Also, a time event can be re-armed to fire
* in a different number of clock ticks by calling the QTimeEvt_rearm()
* function.
*
* \usage
* The following example shows how to arm a one-shot time event from a state
* machine of an active object:
* \include qf_state.c
*/
void QTimeEvt_armX(QTimeEvt * const me,
QTimeEvtCtr const nTicks, QTimeEvtCtr const interval)
{
uint_fast8_t tickRate = (uint_fast8_t)me->super.refCtr_
& (uint_fast8_t)0x7F;
QTimeEvtCtr ctr = me->ctr;
QF_CRIT_STAT_
/** \pre the host AO must be valid, time evnet must be disarmed,
* number of clock ticks cannot be zero, and the signal must be valid.
*/
Q_REQUIRE_ID(100, (me->act != (void *)0)
&& (ctr == (QTimeEvtCtr)0)
&& (nTicks != (QTimeEvtCtr)0)
&& (tickRate < (uint_fast8_t)QF_MAX_TICK_RATE)
&& (me->super.sig >= (QSignal)Q_USER_SIG));
QF_CRIT_ENTRY_();
me->ctr = nTicks;
me->interval = interval;
/* is the time event unlinked?
* NOTE: For the duration of a single clock tick of the specified tick
* rate a time event can be disarmed and yet still linked into the list,
* because un-linking is performed exclusively in the QF_tickX() function.
*/
if ((me->super.refCtr_ & (uint8_t)0x80) == (uint8_t)0) {
me->super.refCtr_ |= (uint8_t)0x80; /* mark as linked */
/* The time event is initially inserted into the separate
* "freshly armed" link list based on QF_timeEvtHead_[tickRate].act.
* Only later, inside the QF_tickX() function, the "freshly armed"
* list is appended to the main list of armed time events based on
* QF_timeEvtHead_[tickRate].next. Again, this is to keep any
* changes to the main list exclusively inside the QF_tickX()
* function.
*/
me->next = (QTimeEvt *)QF_timeEvtHead_[tickRate].act;
QF_timeEvtHead_[tickRate].act = me;
}
QS_BEGIN_NOCRIT_(QS_QF_TIMEEVT_ARM, QS_priv_.teObjFilter, me)
QS_TIME_(); /* timestamp */
QS_OBJ_(me); /* this time event object */
QS_OBJ_(me->act); /* the active object */
QS_TEC_(nTicks); /* the number of ticks */
QS_TEC_(interval); /* the interval */
QS_U8_((uint8_t)tickRate); /* tick rate */
QS_END_NOCRIT_()
QF_CRIT_EXIT_();
}
/*..........................................................................*/
QMutex QK_mutexLock(uint8_t prioCeiling) {
uint8_t mutex;
QF_CRIT_STAT_
QF_CRIT_ENTRY_();
mutex = QK_ceilingPrio_; /* the original QK priority ceiling to return */
if (QK_ceilingPrio_ < prioCeiling) {
QK_ceilingPrio_ = prioCeiling; /* raise the QK priority ceiling */
}
QS_BEGIN_NOCRIT_(QS_QK_MUTEX_LOCK, (void *)0, (void *)0)
QS_TIME_(); /* timestamp */
QS_U8_(mutex); /* the original priority */
QS_U8_(QK_ceilingPrio_); /* the current priority ceiling */
QS_END_NOCRIT_()
QF_CRIT_EXIT_();
return mutex;
}
/*..........................................................................*/
void QMPool_put(QMPool *me, void *b) {
QF_CRIT_STAT_
Q_REQUIRE(me->nFree <= me->nTot); /* # free blocks must be < total */
Q_REQUIRE(QF_PTR_RANGE_(b, me->start, me->end)); /* b must be in range */
QF_CRIT_ENTRY_();
((QFreeBlock *)b)->next = (QFreeBlock *)me->free_head;/* link into list */
me->free_head = b; /* set as new head of the free list */
++me->nFree; /* one more free block in this pool */
QS_BEGIN_NOCRIT_(QS_QF_MPOOL_PUT, QS_mpObj_, me->start)
QS_TIME_(); /* timestamp */
QS_OBJ_(me->start); /* the memory managed by this pool */
QS_MPC_(me->nFree); /* the number of free blocks in the pool */
QS_END_NOCRIT_()
QF_CRIT_EXIT_();
}
/*..........................................................................*/
QTimeEvtCtr QTimeEvt_ctr(QTimeEvt const * const me) {
QTimeEvtCtr ret;
QF_CRIT_STAT_
QF_CRIT_ENTRY_();
ret = me->ctr;
QS_BEGIN_NOCRIT_(QS_QF_TIMEEVT_CTR, QS_priv_.teObjFilter, me)
QS_TIME_(); /* timestamp */
QS_OBJ_(me); /* this time event object */
QS_OBJ_(me->act); /* the target AO */
QS_TEC_(ret); /* the current counter */
QS_TEC_(me->interval); /* the interval */
QS_U8_((uint8_t)(me->super.refCtr_ & (uint8_t)0x7F)); /* tick rate */
QS_END_NOCRIT_()
QF_CRIT_EXIT_();
return ret;
}
//****************************************************************************
/// @description
/// This function removes a given active object from the active objects
/// managed by the QF framework. It should not be called by the application
/// directly, only through the function QP::QMActive::stop().
///
/// @param[in] a pointer to the active object to remove from the framework.
///
/// @note The active object that is removed from the framework can no longer
/// participate in the publish-subscribe event exchange.
///
/// @sa QP::QF::add_()
///
void QF::remove_(QMActive const * const a) {
uint_fast8_t p = a->m_prio;
Q_REQUIRE_ID(200, (static_cast<uint_fast8_t>(0) < p)
&& (p <= static_cast<uint_fast8_t>(QF_MAX_ACTIVE))
&& (active_[p] == a));
QF_CRIT_STAT_
QF_CRIT_ENTRY_();
active_[p] = static_cast<QMActive *>(0); // free-up the priority level
QS_BEGIN_NOCRIT_(QS_QF_ACTIVE_REMOVE, QS::priv_.aoObjFilter, a)
QS_TIME_(); // timestamp
QS_OBJ_(a); // the active object
QS_U8_(p); // the priority of the active object
QS_END_NOCRIT_()
QF_CRIT_EXIT_();
}
/*..........................................................................*/
void QActive_subscribe(QActive const * const me, enum_t const sig) {
uint8_t p = me->prio;
uint8_t i = Q_ROM_BYTE(QF_div8Lkup[p]);
QF_CRIT_STAT_
Q_REQUIRE(((enum_t)Q_USER_SIG <= sig)
&& (sig < QF_maxSignal_)
&& ((uint8_t)0 < p) && (p <= (uint8_t)QF_MAX_ACTIVE)
&& (QF_active_[p] == me));
QF_CRIT_ENTRY_();
QS_BEGIN_NOCRIT_(QS_QF_ACTIVE_SUBSCRIBE, QS_aoObj_, me)
QS_TIME_(); /* timestamp */
QS_SIG_((QSignal)sig); /* the signal of this event */
QS_OBJ_(me); /* this active object */
QS_END_NOCRIT_()
/* set the priority bit */
QF_PTR_AT_(QF_subscrList_, sig).bits[i] |= Q_ROM_BYTE(QF_pwr2Lkup[p]);
QF_CRIT_EXIT_();
}
//****************************************************************************/
/// @description
/// This function is part of the Publish-Subscribe event delivery mechanism
/// available in QF. Subscribing to an event means that the framework will
/// start posting all published events with a given signal @p sig to the
/// event queue of the active object.
///
/// @param[in] sig event signal to subscribe
///
/// The following example shows how the Table active object subscribes
/// to three signals in the initial transition:
/// @include qf_subscribe.c
///
/// @sa QP::QF::publish_(), QP::QMActive::unsubscribe(), and
/// QP::QMActive::unsubscribeAll()
///
void QMActive::subscribe(enum_t const sig) const {
uint_fast8_t p = m_prio;
Q_REQUIRE_ID(300, (Q_USER_SIG <= sig)
&& (sig < QF_maxSignal_)
&& (static_cast<uint_fast8_t>(0) < p)
&& (p <= static_cast<uint_fast8_t>(QF_MAX_ACTIVE))
&& (QF::active_[p] == this));
uint_fast8_t const i =
static_cast<uint_fast8_t>(QF_div8Lkup[p]);
QF_CRIT_STAT_
QF_CRIT_ENTRY_();
QS_BEGIN_NOCRIT_(QS_QF_ACTIVE_SUBSCRIBE, QS::priv_.aoObjFilter, this)
QS_TIME_(); // timestamp
QS_SIG_(sig); // the signal of this event
QS_OBJ_(this); // this active object
QS_END_NOCRIT_()
// set the priority bit
QF_PTR_AT_(QF_subscrList_, sig).m_bits[i] |= QF_pwr2Lkup[p];
QF_CRIT_EXIT_();
}
void QF_tick(void const * const sender)
#endif
{
QTimeEvt *t;
QTimeEvt *prev = (QTimeEvt *)0;
QF_CRIT_STAT_
QF_CRIT_ENTRY_();
QS_BEGIN_NOCRIT_(QS_QF_TICK, (void *)0, (void *)0)
QS_TEC_((QTimeEvtCtr)(++QS_tickCtr_)); /* the tick counter */
QS_END_NOCRIT_()
for (t = QF_timeEvtListHead_; t != (QTimeEvt *)0; t = t->next) {
if (t->ctr == (QTimeEvtCtr)0) { /* time evt. scheduled for removal? */
if (t == QF_timeEvtListHead_) {
QF_timeEvtListHead_ = t->next;
}
else {
Q_ASSERT(prev != (QTimeEvt *)0);
prev->next = t->next;
}
QF_EVT_REF_CTR_DEC_(&t->super); /* mark as not linked */
}
else {
--t->ctr;
if (t->ctr == (QTimeEvtCtr)0) { /* is time evt about to expire? */
if (t->interval != (QTimeEvtCtr)0) { /* periodic time evt? */
t->ctr = t->interval; /* rearm the time event */
}
else {
QS_BEGIN_NOCRIT_(QS_QF_TIMEEVT_AUTO_DISARM, QS_teObj_, t)
QS_OBJ_(t); /* this time event object */
QS_OBJ_(t->act); /* the active object */
QS_END_NOCRIT_()
}
QS_BEGIN_NOCRIT_(QS_QF_TIMEEVT_POST, QS_teObj_, t)
QS_TIME_(); /* timestamp */
QS_OBJ_(t); /* the time event object */
QS_SIG_(t->super.sig); /* signal of this time event */
QS_OBJ_(t->act); /* the active object */
QS_END_NOCRIT_()
QF_CRIT_EXIT_(); /* exit crit. section before posting */
/* QACTIVE_POST() asserts internally if the queue overflows */
QACTIVE_POST(t->act, &t->super, sender);
QF_CRIT_ENTRY_(); /* re-enter crit. section to continue */
if (t->ctr == (QTimeEvtCtr)0) { /* still marked to expire? */
if (t == QF_timeEvtListHead_) {
QF_timeEvtListHead_ = t->next;
}
else {
Q_ASSERT(prev != (QTimeEvt *)0);
prev->next = t->next;
}
QF_EVT_REF_CTR_DEC_(&t->super); /* mark as removed */
}
else {
prev = t;
}
}
else {
prev = t;
}
}
}
/**
* \description
* The "extended" QK scheduler performs all the steps of the regular scheduler
* QK_sched_() and additionally switches the Thread-Local Storage (TLS) and
* handles the extended context-switch.
*
* \arguments
* \arg[in] \c p priority of the next AO to schedule
*
* \note The "extended" QK scheduler needs to be called only to handle
* "asynchronous" preemption, under the assumption that neither the ISRs
* nor the QK idle loop use TLS or the co-processors requiring
* extended context switch (see [PSiCC2] Section 10.4.3).
*
* \note QK_schedExt_() must be always called with interrupts DISABLED.
*
* \note The extended scheduler might enable interrupts internally,
* but always returns with interrupts DISABLED.
*/
void QK_schedExt_(uint_fast8_t p) {
uint_fast8_t pin = QK_currPrio_; /* save the initial priority */
/* thread-local storage used? */
#ifdef QK_TLS
uint_fast8_t pprev = pin;
#endif
QActive *a;
/* extended context-switch used? */
#ifdef QK_EXT_SAVE
/* aren't we preempting the idle loop? (idle loop has prio==0) */
if (pin != (uint_fast8_t)0) {
a = QF_active_[pin]; /* the pointer to the preempted AO */
QK_EXT_SAVE(a); /* save the extended context */
}
#endif
/* loop until have ready-to-run AOs of higher priority than the initial */
do {
QEvt const *e;
a = QF_active_[p]; /* obtain the pointer to the AO */
QK_currPrio_ = p; /* this becomes the current task priority */
/* thread-local storage used? */
#ifdef QK_TLS
/* are we changing threads? */
if (p != pprev) {
QK_TLS(a); /* switch new thread-local storage */
pprev = p;
}
#endif
QS_BEGIN_NOCRIT_(QS_QK_SCHEDULE, QS_priv_.aoObjFilter, a)
QS_TIME_(); /* timestamp */
QS_U8_((uint8_t)p); /* the priority of the AO */
QS_U8_((uint8_t)pin); /* the preempted priority */
QS_END_NOCRIT_()
QF_INT_ENABLE(); /* unconditionally enable interrupts */
/* perform the run-to-completion (RTS) step...
* 1. retrieve the event from the AO's event queue, which by this
* time must be non-empty and QActive_get_() asserts it.
* 2. dispatch the event to the AO's state machine.
* 3. determine if event is garbage and collect it if so
*/
e = QActive_get_(a);
QMSM_DISPATCH(&a->super, e);
QF_gc(e);
QF_INT_DISABLE(); /* disable interrupts */
/* find new highest-priority AO ready to run... */
#if (QF_MAX_ACTIVE <= 8)
QPSet8_findMax(&QK_readySet_, p);
#else
QPSet64_findMax(&QK_readySet_, p);
#endif
/* is the new priority below the current preemption threshold? */
if (p <= pin) {
p = (uint_fast8_t)0;
}
#ifndef QK_NO_MUTEX
/* is the new priority below the mutex ceiling? */
else if (p <= QK_ceilingPrio_) {
p = (uint_fast8_t)0;
}
else {
/* empty */
}
#endif
} while (p != (uint_fast8_t)0);
QK_currPrio_ = pin; /* restore the initial priority */
#if defined(QK_TLS) || defined(QK_EXT_RESTORE)
/* aren't we preempting the idle loop? (idle loop has prio==0) */
if (pin != (uint_fast8_t)0) {
a = QF_active_[pin]; /* the pointer to the preempted AO */
/* thread-local storage used? */
#ifdef QK_TLS
QK_TLS(a); /* restore the original TLS */
#endif
/* extended context-switch used? */
#ifdef QK_EXT_RESTORE
QK_EXT_RESTORE(a); /* restore the extended context */
#endif
}
#endif
}
void QF_tickX_(uint_fast8_t const tickRate, void const * const sender)
#endif
{
QTimeEvt *prev = &QF_timeEvtHead_[tickRate];
QF_CRIT_STAT_
QF_CRIT_ENTRY_();
QS_BEGIN_NOCRIT_(QS_QF_TICK, (void *)0, (void *)0)
QS_TEC_((QTimeEvtCtr)(++prev->ctr)); /* tick ctr */
QS_U8_((uint8_t)tickRate); /* tick rate */
QS_END_NOCRIT_()
/* scan the linked-list of time events at this rate... */
for (;;) {
QTimeEvt *t = prev->next; /* advance down the time evt. list */
/* end of the list? */
if (t == (QTimeEvt *)0) {
/* any new time events armed since the last run of QF_tickX_()? */
if (QF_timeEvtHead_[tickRate].act != (void *)0) {
/* sanity check */
Q_ASSERT_ID(110, prev != (QTimeEvt *)0);
prev->next = (QTimeEvt *)QF_timeEvtHead_[tickRate].act;
QF_timeEvtHead_[tickRate].act = (void *)0;
t = prev->next; /* switch to the new list */
}
else {
break; /* all currently armed time evts. processed */
}
}
/* time event scheduled for removal? */
if (t->ctr == (QTimeEvtCtr)0) {
prev->next = t->next;
t->super.refCtr_ &= (uint8_t)0x7F; /* mark as unlinked */
/* do NOT advance the prev pointer */
QF_CRIT_EXIT_(); /* exit crit. section to reduce latency */
/* prevent merging critical sections, see NOTE1 below */
QF_CRIT_EXIT_NOP();
}
else {
--t->ctr;
/* is time event about to expire? */
if (t->ctr == (QTimeEvtCtr)0) {
QMActive *act = (QMActive *)t->act; /* temp. for volatile */
/* periodic time evt? */
if (t->interval != (QTimeEvtCtr)0) {
t->ctr = t->interval; /* rearm the time event */
prev = t; /* advance to this time event */
}
/* one-shot time event: automatically disarm */
else {
prev->next = t->next;
t->super.refCtr_ &= (uint8_t)0x7F; /* mark as unlinked */
/* do NOT advance the prev pointer */
QS_BEGIN_NOCRIT_(QS_QF_TIMEEVT_AUTO_DISARM,
QS_priv_.teObjFilter, t)
QS_OBJ_(t); /* this time event object */
QS_OBJ_(act); /* the target AO */
QS_U8_((uint8_t)tickRate); /* tick rate */
QS_END_NOCRIT_()
}
QS_BEGIN_NOCRIT_(QS_QF_TIMEEVT_POST, QS_priv_.teObjFilter, t)
QS_TIME_(); /* timestamp */
QS_OBJ_(t); /* the time event object */
QS_SIG_(t->super.sig); /* signal of this time event */
QS_OBJ_(act); /* the target AO */
QS_U8_((uint8_t)tickRate); /* tick rate */
QS_END_NOCRIT_()
QF_CRIT_EXIT_(); /* exit critical section before posting */
/* QACTIVE_POST() asserts internally if the queue overflows */
QACTIVE_POST(act, &t->super, sender);
}
else {
prev = t; /* advance to this time event */
QF_CRIT_EXIT_(); /* exit crit. section to reduce latency */
/* prevent merging critical sections, see NOTE1 below */
QF_CRIT_EXIT_NOP();
}
}
