/*..........................................................................*/
QEvt *QF_newX_(uint_t const evtSize,
uint_t const margin, enum_t const sig)
{
QEvt *e;
uint_t idx;
QS_CRIT_STAT_
/* find the pool index that fits the requested event size ... */
for (idx = (uint_t)0; idx < QF_maxPool_; ++idx) {
if (evtSize <= QF_EPOOL_EVENT_SIZE_(QF_pool_[idx])) {
break;
}
}
Q_ASSERT(idx < QF_maxPool_); /* cannot run out of registered pools */
QS_BEGIN_(QS_QF_NEW, (void *)0, (void *)0)
QS_TIME_(); /* timestamp */
QS_EVS_((QEvtSize)evtSize); /* the size of the event */
QS_SIG_((QSignal)sig); /* the signal of the event */
QS_END_()
QF_EPOOL_GET_(QF_pool_[idx], e, margin); /* get e -- platform-dependent */
if (e != (QEvt *)0) { /* was e allocated correctly? */
e->sig = (QSignal)sig; /* set signal for this event */
e->poolId_ = (uint8_t)(idx + (uint_t)1); /* store the pool ID */
e->refCtr_ = (uint8_t)0; /* set the reference counter to 0 */
}
else { /* event cannot be allocated */
Q_ASSERT(margin != (uint_t)0); /* must tollerate bad allocation */
}
return e; /* can't be NULL if we can't tollerate bad allocation */
}
//............................................................................
QEvent *QF::new_(uint16_t evtSize, QSignal sig) {
// find the pool id that fits the requested event size ...
uint8_t id = (uint8_t)0;
while (evtSize > QF_EPOOL_EVENT_SIZE_(QF_pool_[id])) {
++id;
Q_ASSERT(id < QF_maxPool_); // cannot run out of registered pools
}
QS_INT_LOCK_KEY_
QS_BEGIN_(QS_QF_NEW, (void *)0, (void *)0)
QS_TIME_(); // timestamp
QS_EVS_(evtSize); // the size of the event
QS_SIG_(sig); // the signal of the event
QS_END_()
QEvent *e;
QF_EPOOL_GET_(QF_pool_[id], e);
Q_ASSERT(e != (QEvent *)0); // pool must not run out of events
e->sig = sig; // set signal for this event
// store the dynamic attributes of the event:
// the pool ID and the reference counter == 0
e->dynamic_ = (uint8_t)((id + 1) << 6);
return e;
}
//****************************************************************************
/// @description
/// Allocates an event dynamically from one of the QF event pools.
///
/// @param[in] evtSize the size (in bytes) of the event to allocate
/// @param[in] margin the number of un-allocated events still available
/// in a given event pool after the allocation completes
/// @param[in] sig the signal to be assigned to the allocated event
///
/// @returns pointer to the newly allocated event. This pointer can be NULL
/// only if margin!=0 and the event cannot be allocated with the specified
/// margin still available in the given pool.
///
/// @note The internal QF function QP::QF::newX_() raises an assertion when
/// the margin argument is 0 and allocation of the event turns out to be
/// impossible due to event pool depletion, or incorrect (too big) size
/// of the requested event.
///
/// @note The application code should not call this function directly.
/// The only allowed use is thorough the macros Q_NEW() or Q_NEW_X().
///
QEvt *QF::newX_(uint_fast16_t const evtSize,
uint_fast16_t const margin, enum_t const sig)
{
uint_fast8_t idx;
// find the pool id that fits the requested event size ...
for (idx = static_cast<uint_fast8_t>(0); idx < QF_maxPool_; ++idx) {
if (evtSize <= QF_EPOOL_EVENT_SIZE_(QF_pool_[idx])) {
break;
}
}
// cannot run out of registered pools
Q_ASSERT_ID(310, idx < QF_maxPool_);
QS_CRIT_STAT_
QS_BEGIN_(QS_QF_NEW, static_cast<void *>(0), static_cast<void *>(0))
QS_TIME_(); // timestamp
QS_EVS_(static_cast<QEvtSize>(evtSize)); // the size of the event
QS_SIG_(static_cast<QSignal>(sig)); // the signal of the event
QS_END_()
QEvt *e;
QF_EPOOL_GET_(QF_pool_[idx], e, margin); // get e -- platform-dependent
// was e allocated correctly?
if (e != static_cast<QEvt const *>(0)) {
e->sig = static_cast<QSignal>(sig); // set the signal
// store pool ID
e->poolId_ = static_cast<uint8_t>(
idx + static_cast<uint_fast8_t>(1));
// initialize the reference counter to 0
e->refCtr_ = static_cast<uint8_t>(0);
}
else {
// event was not allocated, assert that the caller provided non-zero
// margin, which means that they can tollerate bad allocation
Q_ASSERT_ID(320, margin != static_cast<uint_fast16_t>(0));
}
return e;
}
