/*..........................................................................*/
void QF_poolInit(void *poolSto, uint32_t poolSize, QEventSize evtSize) {
/* cannot exceed the number of available memory pools */
/* -------------------------------------------------------------------------
This precondition (see Chapter 6, “Customized Assertions in C/C++”)
asserts that the application does not attempt to initialize more than the
supported number of event pools (currently three).
-------------------------------------------------------------------------*/
Q_REQUIRE(QF_maxPool_ < (uint8_t)Q_DIM(QF_pool_));
/* please initialize event pools in ascending order of evtSize: */
/* -------------------------------------------------------------------------
For possibly quick event allocation, the event pool array QF_pool_[]
must be sorted in ascending order of block sizes. This precondition asserts
that the application initializes event pools in the increasing order of the
event sizes. This assertion significantly simplifies the QF_poolInit()
function without causing any true inconvenience for the application
implementer.
-------------------------------------------------------------------------*/
Q_REQUIRE((QF_maxPool_ == (uint8_t)0)
|| (QF_EPOOL_EVENT_SIZE_(QF_pool_[QF_maxPool_ - 1]) < evtSize));
/* perfom the platform-dependent initialization of the pool */
QF_EPOOL_INIT_(QF_pool_[QF_maxPool_], poolSto, poolSize, evtSize);
++QF_maxPool_; /* one more pool */
}
/*..........................................................................*/
void QF_poolInit(void *poolSto, uint32_t poolSize, QEventSize evtSize) {
/* cannot exceed the number of available memory pools */
Q_REQUIRE(QF_maxPool_ < (uint8_t)Q_DIM(QF_pool_));
/* please initialize event pools in ascending order of evtSize: */
Q_REQUIRE((QF_maxPool_ == (uint8_t)0)
|| (QF_EPOOL_EVENT_SIZE_(QF_pool_[QF_maxPool_ - (uint8_t)1])
< evtSize));
/* perfom the platform-dependent initialization of the pool */
QF_EPOOL_INIT_(QF_pool_[QF_maxPool_], poolSto, poolSize, evtSize);
++QF_maxPool_; /* one more pool */
}
/**
* \description
* This function initializes one event pool at a time and must be called
* exactly once for each event pool before the pool can be used.
*
* \arguments
* \arg[in] \c poolSto pointer to the storage for the event pool
* \arg[in] \c poolSize size of the storage for the pool in bytes
* \arg[in] \c evtSize the block-size of the pool in bytes, which determines
* the maximum size of events that can be allocated from the pool.
*
* \note
* You might initialize many event pools by making many consecutive calls
* to the QF_poolInit() function. However, for the simplicity of the internal
* implementation, you must initialize event pools in the ascending order of
* the event size.
*
* Many RTOSes provide fixed block-size heaps, a.k.a. memory pools that can
* be adapted for QF event pools. In case such support is missing, QF provides
* a native QF event pool implementation. The macro #QF_EPOOL_TYPE_ determines
* the type of event pool used by a particular QF port. See structure ::QMPool
* for more information.
*
* \note The actual number of events available in the pool might be actually
* less than (\a poolSize / \a evtSize) due to the internal alignment
* of the blocks that the pool might perform. You can always check the
* capacity of the pool by calling QF_getPoolMin().
*
* \note The dynamic allocation of events is optional, meaning that you
* might choose not to use dynamic events. In that case calling QF_poolInit()
* and using up memory for the memory blocks is unnecessary.
*
* \sa QF initialization example for QF_init()
*/
void QF_poolInit(void * const poolSto, uint_fast16_t const poolSize,
uint_fast16_t const evtSize)
{
/** \pre cannot exceed the number of available memory pools */
Q_REQUIRE_ID(100, QF_maxPool_ < (uint_fast8_t)Q_DIM(QF_pool_));
/** \pre please initialize event pools in ascending order of evtSize: */
Q_REQUIRE_ID(101, (QF_maxPool_ == (uint_fast8_t)0)
|| (QF_EPOOL_EVENT_SIZE_(QF_pool_[QF_maxPool_ - (uint_fast8_t)1])
< evtSize));
/* perform the platform-dependent initialization of the pool */
QF_EPOOL_INIT_(QF_pool_[QF_maxPool_],
poolSto, poolSize, evtSize);
++QF_maxPool_; /* one more pool */
}
