/*..........................................................................*/ 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; }