GitHub/qpc
1
0
Fork 0
mirror of https://github.com/QuantumLeaps/qpc.git synced 2025-01-28 07:03:10 +08:00
Code Issues Projects Releases Wiki Activity

6.1.1b

Browse Source
This commit is contained in:
QL 2018-02-22 11:33:12 -05:00
parent 5bffd59416
commit a4f97118a0
3 changed files with 46 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/qxk/qxk_mutex.c
View File

@ -5,8 +5,8 @@
* QXMutex_unlock() definitions. * QXMutex_unlock() definitions.
* @cond * @cond
****************************************************************************** ******************************************************************************
* Last updated for version 6.0.3 * Last updated for version 6.1.1
* Last updated on 2017-12-08 * Last updated on 2018-02-22
* *
* Q u a n t u m L e a P s * Q u a n t u m L e a P s
* --------------------------- * ---------------------------
@ -33,7 +33,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
* *
* Contact information: * Contact information:
* https://state-machine.com * https://www.state-machine.com
* mailto:info@state-machine.com * mailto:info@state-machine.com
****************************************************************************** ******************************************************************************
* @endcond * @endcond
@ -94,10 +94,11 @@ void QXMutex_init(QXMutex * const me, uint_fast8_t ceiling) {
Q_REQUIRE_ID(100, Q_REQUIRE_ID(100,
(ceiling <= (uint_fast8_t)QF_MAX_ACTIVE) (ceiling <= (uint_fast8_t)QF_MAX_ACTIVE)
&& ((ceiling == (uint_fast8_t)0) && ((ceiling == (uint_fast8_t)0)
|| (QF_active_[ceiling] == (QActive *)0))); || (QF_active_[ceiling] == (QActive *)0)));
me->ceiling = (uint8_t)ceiling; me->ceiling = (uint8_t)ceiling;
me->lockNest = (uint8_t)0; me->lockNest = (uint8_t)0;
me->holderPrio = (uint8_t)0;
QF_bzero(&me->waitSet, (uint_fast16_t)sizeof(me->waitSet)); QF_bzero(&me->waitSet, (uint_fast16_t)sizeof(me->waitSet));
if (ceiling != (uint_fast8_t)0) { if (ceiling != (uint_fast8_t)0) {
@ -166,7 +167,8 @@ bool QXMutex_lock(QXMutex * const me,
QPSet_remove(&QXK_attr_.readySet, QPSet_remove(&QXK_attr_.readySet,
(uint_fast8_t)curr->super.startPrio); (uint_fast8_t)curr->super.startPrio);
QPSet_insert(&QXK_attr_.readySet, (uint_fast8_t)curr->super.prio); QPSet_insert(&QXK_attr_.readySet,
(uint_fast8_t)curr->super.prio);
} }
me->holderPrio = (uint8_t)curr->super.startPrio; me->holderPrio = (uint8_t)curr->super.startPrio;
@ -208,9 +210,10 @@ bool QXMutex_lock(QXMutex * const me,
QF_CRIT_EXIT_NOP(); /* BLOCK here */ QF_CRIT_EXIT_NOP(); /* BLOCK here */
QF_CRIT_ENTRY_(); QF_CRIT_ENTRY_();
/* the blocking object must be this mutex */ /* the blocking object of the current thread must be this mutex */
Q_ASSERT_ID(240, curr->super.super.temp.obj == (QMState *)me); Q_ASSERT_ID(240, curr->super.super.temp.obj == (QMState *)me);
curr->super.super.temp.obj = (QMState const *)0; /* clear */
curr->super.super.temp.obj = (QMState *)0; /* clear blocking obj. */
} }
QF_CRIT_EXIT_(); QF_CRIT_EXIT_();
@ -299,8 +302,8 @@ bool QXMutex_tryLock(QXMutex * const me) {
else { /* the mutex is alredy locked by a different thread */ else { /* the mutex is alredy locked by a different thread */
if (me->ceiling != (uint8_t)0) { if (me->ceiling != (uint8_t)0) {
/* the prio slot must be claimed by the mutex holder */ /* the prio slot must be claimed by the mutex holder */
Q_ASSERT_ID(330, Q_ASSERT_ID(330, (me->holderPrio != (uint8_t)0)
QF_active_[me->ceiling] == QF_active_[me->holderPrio]); && (QF_active_[me->ceiling] == QF_active_[me->holderPrio]));
} }
curr = (QActive *)0; /* means that mutex is NOT available */ curr = (QActive *)0; /* means that mutex is NOT available */
} }
@ -369,7 +372,7 @@ void QXMutex_unlock(QXMutex * const me) {
/* the mutex no longer held by a thread */ /* the mutex no longer held by a thread */
me->holderPrio = (uint8_t)0; me->holderPrio = (uint8_t)0;
QS_BEGIN_NOCRIT_(QS_MUTEX_UNLOCK, (void *)0, (void *)0) QS_BEGIN_NOCRIT_(QS_MUTEX_UNLOCK, (void *)0, curr)
QS_TIME_(); /* timestamp */ QS_TIME_(); /* timestamp */
QS_2U8_((uint8_t)curr->startPrio, /* the start priority */ QS_2U8_((uint8_t)curr->startPrio, /* the start priority */
me->ceiling); /* the mutex ceiling */ me->ceiling); /* the mutex ceiling */
@ -414,6 +417,7 @@ void QXMutex_unlock(QXMutex * const me) {
/* make thr the new mutex holder */ /* make thr the new mutex holder */
me->holderPrio = (uint8_t)thr->super.startPrio; me->holderPrio = (uint8_t)thr->super.startPrio;
/* make the thread ready to run (at the ceiling prio) */ /* make the thread ready to run (at the ceiling prio) */
QPSet_insert(&QXK_attr_.readySet, (uint_fast8_t)thr->super.prio); QPSet_insert(&QXK_attr_.readySet, (uint_fast8_t)thr->super.prio);
@ -437,7 +441,7 @@ void QXMutex_unlock(QXMutex * const me) {
QXK_activate_(); /* activate a basic thread */ QXK_activate_(); /* activate a basic thread */
} }
} }
else { /* releasing the */ else { /* releasing the mutex */
--me->lockNest; /* release one level */ --me->lockNest; /* release one level */
} }
QF_CRIT_EXIT_(); QF_CRIT_EXIT_();

16
src/qxk/qxk_sema.c
View File

@ -4,8 +4,8 @@
* @ingroup qxk * @ingroup qxk
* @cond * @cond
****************************************************************************** ******************************************************************************
* Last updated for version 6.0.3 * Last updated for version 6.1.1
* Last updated on 2017-12-08 * Last updated on 2018-02-22
* *
* Q u a n t u m L e a P s * Q u a n t u m L e a P s
* --------------------------- * ---------------------------
@ -32,7 +32,7 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
* *
* Contact information: * Contact information:
* https://state-machine.com * https://www.state-machine.com
* mailto:info@state-machine.com * mailto:info@state-machine.com
****************************************************************************** ******************************************************************************
* @endcond * @endcond
@ -98,7 +98,7 @@ void QXSemaphore_init(QXSemaphore * const me, uint_fast16_t count,
* resumes the highest-priority extended thread waiting for the semaphore. * resumes the highest-priority extended thread waiting for the semaphore.
* *
* @param[in,out] me pointer (see @ref oop) * @param[in,out] me pointer (see @ref oop)
* @param[in] nTicks number of clock ticks (at the associated rate) * @param[in] nTicks number of clock ticks (at the associated rate)
* to wait for the semaphore. The value of * to wait for the semaphore. The value of
* QXTHREAD_NO_TIMEOUT indicates that no timeout will * QXTHREAD_NO_TIMEOUT indicates that no timeout will
* occur and the semaphore will wait indefinitely. * occur and the semaphore will wait indefinitely.
@ -147,7 +147,7 @@ bool QXSemaphore_wait(QXSemaphore * const me, uint_fast16_t const nTicks) {
QF_CRIT_ENTRY_(); QF_CRIT_ENTRY_();
/* the blocking object must be this semaphore */ /* the blocking object must be this semaphore */
Q_ASSERT_ID(210, curr->super.super.temp.obj == (QMState *)me); Q_ASSERT_ID(210, curr->super.super.temp.obj == (QMState *)me);
curr->super.super.temp.obj = (QMState const *)0; /* clear */ curr->super.super.temp.obj = (QMState *)0; /* clear */
} }
QF_CRIT_EXIT_(); QF_CRIT_EXIT_();
@ -229,8 +229,14 @@ bool QXSemaphore_signal(QXSemaphore * const me) {
QPSet_remove(&me->waitSet, p); QPSet_remove(&me->waitSet, p);
thr = (QXThread *)QF_active_[p]; thr = (QXThread *)QF_active_[p];
/* the thread must be registered in QF;
* the thread must be extended;
* must be blocked on this semaphore; and
* the semaphore count must be zero (semaphore not signaled)
*/
Q_ASSERT_ID(410, (thr != (QXThread *)0) /* must be registered */ Q_ASSERT_ID(410, (thr != (QXThread *)0) /* must be registered */
&& (thr->super.osObject != (struct QActive *)0) /* extended thr.*/ && (thr->super.osObject != (struct QActive *)0) /* extended thr.*/
&& (thr->super.super.temp.obj == (QMState const *)me)
&& (me->count == (uint16_t)0)); /* sema counter must be 0 */ && (me->count == (uint16_t)0)); /* sema counter must be 0 */
/* disarm the internal time event */ /* disarm the internal time event */

33
src/qxk/qxk_xthr.c
View File

@ -316,7 +316,9 @@ static bool QXThread_post_(QActive * const me, QEvt const * const e,
else { else {
/* insert event into the ring buffer (FIFO) */ /* insert event into the ring buffer (FIFO) */
QF_PTR_AT_(me->eQueue.ring, me->eQueue.head) = e; QF_PTR_AT_(me->eQueue.ring, me->eQueue.head) = e;
if (me->eQueue.head == (QEQueueCtr)0) { /*need to wrap head?*/
/* need to wrap the head counter? */
if (me->eQueue.head == (QEQueueCtr)0) {
me->eQueue.head = me->eQueue.end; /* wrap around */ me->eQueue.head = me->eQueue.end; /* wrap around */
} }
--me->eQueue.head; /* advance the head (counter clockwise) */ --me->eQueue.head; /* advance the head (counter clockwise) */
@ -333,12 +335,12 @@ static bool QXThread_post_(QActive * const me, QEvt const * const e,
QS_BEGIN_NOCRIT_(QS_QF_ACTIVE_POST_ATTEMPT, QS_BEGIN_NOCRIT_(QS_QF_ACTIVE_POST_ATTEMPT,
QS_priv_.locFilter[AO_OBJ], me) QS_priv_.locFilter[AO_OBJ], me)
QS_TIME_(); /* timestamp */ QS_TIME_(); /* timestamp */
QS_OBJ_(sender); /* the sender object */ QS_OBJ_(sender); /* the sender object */
QS_SIG_(e->sig); /* the signal of the event */ QS_SIG_(e->sig); /* the signal of the event */
QS_OBJ_(me); /* this active object (recipient) */ QS_OBJ_(me); /* this active object (recipient) */
QS_2U8_(e->poolId_, e->refCtr_); /* pool Id & ref Count */ QS_2U8_(e->poolId_, e->refCtr_); /* pool Id & ref Count */
QS_EQC_(nFree); /* number of free entries */ QS_EQC_(nFree); /* number of free entries */
QS_EQC_((QEQueueCtr)margin); /* margin requested */ QS_EQC_((QEQueueCtr)margin); /* margin requested */
QS_END_NOCRIT_() QS_END_NOCRIT_()
@ -381,9 +383,10 @@ static void QXThread_postLIFO_(QActive * const me, QEvt const * const e) {
* receive QP events directly into its own built-in event queue from an ISR, * receive QP events directly into its own built-in event queue from an ISR,
* basic thread (AO), or another extended thread. * basic thread (AO), or another extended thread.
* *
* If QXThread_queueGet() is called when no events are present in the thread's * If QXThread_queueGet() is called when no events are present in the
* event queue, the operation blocks the current extended thread until either * thread's private event queue, the operation blocks the current extended
* an event is received, or a user-specified timeout expires. * thread until either an event is received, or a user-specified timeout
* expires.
* *
* @param[in] nTicks number of clock ticks (at the associated rate) * @param[in] nTicks number of clock ticks (at the associated rate)
* to wait for the event to arrive. The value of * to wait for the event to arrive. The value of
@ -451,11 +454,11 @@ QEvt const *QXThread_queueGet(uint_fast16_t const nTicks) {
QS_BEGIN_NOCRIT_(QS_QF_ACTIVE_GET, QS_BEGIN_NOCRIT_(QS_QF_ACTIVE_GET,
QS_priv_.locFilter[AO_OBJ], thr) QS_priv_.locFilter[AO_OBJ], thr)
QS_TIME_(); /* timestamp */ QS_TIME_(); /* timestamp */
QS_SIG_(e->sig); /* the signal of this event */ QS_SIG_(e->sig); /* the signal of this event */
QS_OBJ_(&thr->super); /* this active object */ QS_OBJ_(&thr->super); /* this active object */
QS_2U8_(e->poolId_, e->refCtr_); /* pool Id & ref Count */ QS_2U8_(e->poolId_, e->refCtr_); /* pool Id & ref Count */
QS_EQC_(nFree); /* number of free entries */ QS_EQC_(nFree); /* number of free entries */
QS_END_NOCRIT_() QS_END_NOCRIT_()
} }
else { else {
@ -466,8 +469,8 @@ QEvt const *QXThread_queueGet(uint_fast16_t const nTicks) {
QS_BEGIN_NOCRIT_(QS_QF_ACTIVE_GET_LAST, QS_BEGIN_NOCRIT_(QS_QF_ACTIVE_GET_LAST,
QS_priv_.locFilter[AO_OBJ], thr) QS_priv_.locFilter[AO_OBJ], thr)
QS_TIME_(); /* timestamp */ QS_TIME_(); /* timestamp */
QS_SIG_(e->sig); /* the signal of this event */ QS_SIG_(e->sig); /* the signal of this event */
QS_OBJ_(&thr->super); /* this active object */ QS_OBJ_(&thr->super); /* this active object */
QS_2U8_(e->poolId_, e->refCtr_); /* pool Id & ref Count */ QS_2U8_(e->poolId_, e->refCtr_); /* pool Id & ref Count */
QS_END_NOCRIT_() QS_END_NOCRIT_()
@ -580,7 +583,7 @@ bool QXThread_teDisarm_(QXThread * const me) {
} }
/****************************************************************************/ /****************************************************************************/
/*! delay (timed block) the current extended thread (static, no me-pointer) */ /*! delay (timed blocking of) the current thread (static, no me-ptr) */
bool QXThread_delay(uint_fast16_t const nTicks) { bool QXThread_delay(uint_fast16_t const nTicks) {
QXThread *thr; QXThread *thr;
QF_CRIT_STAT_ QF_CRIT_STAT_