Dining Philosopher Problem (DPP) example with the "Orthogonal Component" state pattern. In this implemetnation, the Philosophers (Philos) are not active objects, but rather state-machine components of the Table active object.
QHsm_ctor(&me->super, Q_STATE_CAST(&Philo_initial));
me->num = num;
me->tickCtr = 0U;
me->tickCtr = THINK_TIME;
me->tickCtr = 0U;
Q_ERROR(); /* these events should never arrive in this state */
QACTIVE_POST(&AO_Table, HUNGRY_SIG, me->num);
Q_ERROR(); /* this event should never arrive in this state */
me->tickCtr = EAT_TIME;
me->tickCtr = 0U;
QACTIVE_POST(QF_ACTIVE_CAST(&AO_Table), DONE_SIG, me->num);
Q_ERROR(); /* these events should never arrive in this state */
uint8_t n;
for (n = 0U; n < N_PHILO; ++n) {
QHSM_INIT(&me->philo_pool[n].super);
me->fork[n] = FREE;
me->isHungry[n] = 0U;
BSP_displayPhilStat(n, "thinking");
}
// request periodic timeout in 1 clock tick and every 1 tick
QActive_armX(&me->super, 0U, 1U, 1U);
Q_ERROR();
uint8_t n;
for (n = 0U; n < N_PHILO; ++n) { // for all "Philo" components...
Philo *philo = &me->philo_pool[n];
if (philo->tickCtr != 0U) { // is the "Philo" tick counter runnning?
if (--philo->tickCtr == 0U) { // is the "Philo" tick expiring?
// synchronously dispatch to component
Q_SIG(philo) = Q_TIMEOUT_SIG;
Q_PAR(philo) = n;
QHSM_DISPATCH(&philo->super);
}
}
}
uint8_t n;
for (n = 0U; n < N_PHILO; ++n) { /* give permissions to eat... */
if ((me->isHungry[n] != 0U)
&& (me->fork[LEFT(n)] == FREE)
&& (me->fork[n] == FREE))
{
me->fork[LEFT(n)] = USED;
me->fork[n] = USED;
/* synchronously dispatch to philo_pool[n] */
Q_SIG(&me->philo_pool[n]) = EAT_SIG;
Q_PAR(&me->philo_pool[n]) = n;
QHSM_DISPATCH(&me->philo_pool[n].super);
me->isHungry[n] = 0U;
BSP_displayPhilStat(n, "eating ");
}
}
uint8_t n, m;
n = (uint8_t)Q_PAR(me);
/* philo ID must be in range and he must be not hungry */
Q_ASSERT((n < N_PHILO) && (me->isHungry[n] == 0U));
BSP_displayPhilStat(n, "hungry ");
m = LEFT(n);
(me->fork[m] == FREE) && (me->fork[n] == FREE)
me->fork[m] = USED;
me->fork[n] = USED;
/* synchronously dispatch to philo_pool[n] */
Q_SIG(&me->philo_pool[n]) = EAT_SIG;
Q_PAR(&me->philo_pool[n]) = n;
QHSM_DISPATCH(&me->philo_pool[n].super);
BSP_displayPhilStat(n, "eating ");
else
me->isHungry[n] = 1U;
uint8_t n, m;
n = (uint8_t)Q_PAR(me);
/* phil ID must be in range and he must be not hungry */
Q_ASSERT((n < N_PHILO) && (me->isHungry[n] == 0U));
BSP_displayPhilStat(n, "thinking");
m = LEFT(n);
/* both forks of Philo[n] must be used */
Q_ASSERT((me->fork[n] == USED) && (me->fork[m] == USED));
me->fork[m] = FREE;
me->fork[n] = FREE;
m = RIGHT(n); /* check the right neighbor */
if ((me->isHungry[m] != 0U) && (me->fork[m] == FREE)) {
me->fork[n] = USED;
me->fork[m] = USED;
me->isHungry[m] = 0U;
/* synchronously dispatch to philo_pool[m] */
Q_SIG(&me->philo_pool[m]) = EAT_SIG;
Q_PAR(&me->philo_pool[m]) = m;
QHSM_DISPATCH(&me->philo_pool[m].super);
BSP_displayPhilStat(m, "eating ");
}
m = LEFT(n); /* check the left neighbor */
n = LEFT(m); /* left fork of the left neighbor */
if ((me->isHungry[m] != 0U) && (me->fork[n] == FREE)) {
me->fork[m] = USED;
me->fork[n] = USED;
me->isHungry[m] = 0U;
/* synchronously dispatch to philo_pool[m] */
Q_SIG(&me->philo_pool[m]) = EAT_SIG;
Q_PAR(&me->philo_pool[m]) = m;
QHSM_DISPATCH(&me->philo_pool[m].super);
BSP_displayPhilStat(m, "eating ");
}
Q_ERROR();
BSP_displayPaused(1U);
BSP_displayPaused(0U);
uint8_t n = (uint8_t)Q_PAR(me);
/* philo ID must be in range and he must be not hungry */
Q_ASSERT((n < N_PHILO) && (me->isHungry[n] == 0U));
me->isHungry[n] = 1U;
BSP_displayPhilStat(n, "hungry ");
uint8_t n, m;
n = (uint8_t)Q_PAR(me);
/* philo ID must be in range and he must be not hungry */
Q_ASSERT((n < N_PHILO) && (me->isHungry[n] == 0U));
BSP_displayPhilStat(n, "thinking");
m = LEFT(n);
/* both forks of Phil[n] must be used */
Q_ASSERT((me->fork[n] == USED) && (me->fork[m] == USED));
me->fork[m] = FREE;
me->fork[n] = FREE;
uint8_t n;
Table *me = &AO_Table;
QActive_ctor(&me->super, Q_STATE_CAST(&Table_initial));
for (n = 0U; n < N_PHILO; ++n) {
Philo_ctor(&me->philo_pool[n], n);
me->fork[n] = FREE;
me->isHungry[n] = 0U;
}
#ifndef DPP_H
#define DPP_H
enum DPPSignals {
EAT_SIG = Q_USER_SIG, /* published by Table to let a philosopher eat */
DONE_SIG, /* published by Philosopher when done eating */
PAUSE_SIG, /* published by BSP to pause the application */
SERVE_SIG, /* published by BSP to pause the application */
TERMINATE_SIG, /* published by BSP to terminate the application */
HUNGRY_SIG, /* posted direclty to Table from hungry Philo */
MAX_SIG /* the last signal */
};
/* number of philosophers */
#define N_PHILO ((uint8_t)10)
$declare${AOs::Philo}
$declare${AOs::AO_Table}
$declare${AOs::Table_ctor}
#endif /* DPP_H */
#include "qpn.h" /* QP-nano port */
#include "bsp.h" /* Board Support Package */
#include "dpp.h" /* Application interface */
Q_DEFINE_THIS_MODULE("philo")
/* Active object class -----------------------------------------------------*/
/* Local objects -----------------------------------------------------------*/
#define THINK_TIME \
(QTimeEvtCtr)((BSP_random() % BSP_TICKS_PER_SEC) + (BSP_TICKS_PER_SEC/2U))
#define EAT_TIME \
(QTimeEvtCtr)((BSP_random() % BSP_TICKS_PER_SEC) + BSP_TICKS_PER_SEC)
/* Philo definition --------------------------------------------------------*/
$define${AOs::Philo}
#include "qpn.h" /* QP-nano port */
#include "bsp.h" /* Board Support Package */
#include "dpp.h" /* Application interface */
Q_DEFINE_THIS_MODULE("table")
/* Active object class -----------------------------------------------------*/
$declare${AOs::Table}
/* Global objects ----------------------------------------------------------*/
$define${AOs::AO_Table}
#define RIGHT(n_) ((uint8_t)(((n_) + (N_PHILO - 1U)) % N_PHILO))
#define LEFT(n_) ((uint8_t)(((n_) + 1U) % N_PHILO))
#define FREE ((uint8_t)0)
#define USED ((uint8_t)1)
/*..........................................................................*/
$define${AOs::Table_ctor}
$define${AOs::Table}