qf_mem.cpp

Go to the documentation of this file.

//$file${src::qf::qf_mem.cpp} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
//
// Model: qpcpp.qm
// File:  ${src::qf::qf_mem.cpp}
//
// This code has been generated by QM 7.0.0 <www.state-machine.com/qm>.
// DO NOT EDIT THIS FILE MANUALLY. All your changes will be lost.
//
// Copyright (C) 2005 Quantum Leaps, LLC. All rights reserved.
//
//                    Q u a n t u m  L e a P s
//                    ------------------------
//                    Modern Embedded Software
//
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-QL-commercial
//
// The QP/C++ software is dual-licensed under the terms of the open-source
// GNU General Public License (GPL) or under the terms of one of the closed-
// source Quantum Leaps commercial licenses.
//
// Redistributions in source code must retain this top-level comment block.
// Plagiarizing this software to sidestep the license obligations is illegal.
//
// NOTE:
// The GPL does NOT permit the incorporation of this code into proprietary
// programs. Please contact Quantum Leaps for commercial licensing options,
// which expressly supersede the GPL and are designed explicitly for
// closed-source distribution.
//
// Quantum Leaps contact information:
// <www.state-machine.com/licensing>
// <info@state-machine.com>
//
//$endhead${src::qf::qf_mem.cpp} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
#define QP_IMPL             // this is QP implementation
#include "qp_port.hpp"      // QP port
#include "qp_pkg.hpp"       // QP package-scope interface
#include "qsafe.h"          // QP Functional Safety (FuSa) Subsystem
#ifdef Q_SPY                // QS software tracing enabled?
    #include "qs_port.hpp"  // QS port
    #include "qs_pkg.hpp"   // QS facilities for pre-defined trace records
#else
    #include "qs_dummy.hpp" // disable the QS software tracing
#endif // Q_SPY
 
// unnamed namespace for local definitions with internal linkage
namespace {
Q_DEFINE_THIS_MODULE("qf_mem")
} // unnamed namespace
 
//$skip${QP_VERSION} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
// Check for the minimum required QP version
#if (QP_VERSION < 730U) || (QP_VERSION != ((QP_RELEASE^4294967295U)%0x2710U))
#error qpcpp version 7.3.0 or higher required
#endif
//$endskip${QP_VERSION} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
//$define${QF::QMPool} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
namespace QP {
 
//${QF::QMPool} ..............................................................
 
//${QF::QMPool::init} ........................................................
void QMPool::init(
    void * const poolSto,
    std::uint_fast32_t const poolSize,
    std::uint_fast16_t const blockSize) noexcept
{
    QF_CRIT_STAT
    QF_CRIT_ENTRY();
    QF_MEM_SYS();
 
    Q_REQUIRE_INCRIT(100, poolSto != nullptr);
    Q_REQUIRE_INCRIT(101,
        poolSize >= static_cast<std::uint_fast32_t>(sizeof(QFreeBlock)));
    Q_REQUIRE_INCRIT(102,
        static_cast<std::uint_fast16_t>(blockSize + sizeof(QFreeBlock))
            > blockSize);
 
    m_free_head = static_cast<QFreeBlock *>(poolSto);
 
    // find # free blocks in a memory block, NO DIVISION
    m_blockSize = static_cast<QMPoolSize>(2U * sizeof(void *));
    std::uint_fast16_t nblocks = 1U;
    while (m_blockSize < static_cast<QMPoolSize>(blockSize)) {
        m_blockSize += static_cast<QMPoolSize>(sizeof(QFreeBlock));
        ++nblocks;
    }
 
    // the pool buffer must fit at least one rounded-up block
    Q_ASSERT_INCRIT(110, poolSize >= m_blockSize);
 
    // start at the head of the free list
    QFreeBlock *fb = m_free_head;
    std::uint32_t nTot = 1U; // the last block already in the list
 
    // chain all blocks together in a free-list...
    for (std::uint_fast32_t size = poolSize - m_blockSize;
         size >= static_cast<std::uint_fast32_t>(m_blockSize);
         size -= static_cast<std::uint_fast32_t>(m_blockSize))
    {
        fb->m_next = &fb[nblocks]; // point next link to next block
    #ifndef Q_UNSAFE
        fb->m_next_dis = ~Q_PTR2UINT_CAST_(fb->m_next);
    #endif
        fb = fb->m_next; // advance to the next block
        ++nTot;          // one more free block in the pool
    }
 
    // dynamic range check
    #if (QF_MPOOL_CTR_SIZE == 1U)
    Q_ENSURE_INCRIT(190, nTot < 0xFFU);
    #elif (QF_MPOOL_CTR_SIZE == 2U)
    Q_ENSURE_INCRIT(190, nTot < 0xFFFFU);
    #endif
 
    fb->m_next  = nullptr; // the last link points to NULL
 
    m_nTot  = static_cast<QMPoolCtr>(nTot);
    m_nFree = m_nTot;  // all blocks are free
    m_start = static_cast<QFreeBlock *>(poolSto); // original start
    m_end   = fb;      // the last block in this pool
 
    #ifndef Q_UNSAFE
    m_free_head_dis =
        static_cast<std::uintptr_t>(~Q_PTR2UINT_CAST_(m_free_head));
    m_nFree_dis    = static_cast<QMPoolCtr>(~m_nFree);
    m_nMin         = m_nTot;  // the minimum # free blocks
    fb->m_next_dis = ~Q_PTR2UINT_CAST_(fb->m_next);
    #endif
 
    QF_MEM_APP();
    QF_CRIT_EXIT();
}
 
//${QF::QMPool::get} .........................................................
void * QMPool::get(
    std::uint_fast16_t const margin,
    std::uint_fast8_t const qsId) noexcept
{
    #ifndef Q_SPY
    Q_UNUSED_PAR(qsId);
    #endif
 
    QF_CRIT_STAT
    QF_CRIT_ENTRY();
    QF_MEM_SYS();
 
    // get volatile into temporaries
    QFreeBlock *fb = m_free_head;
    QMPoolCtr nFree = m_nFree;
 
    #ifndef Q_UNSAFE
    Q_INVARIANT_INCRIT(301, Q_PTR2UINT_CAST_(fb)
        == static_cast<std::uintptr_t>(~m_free_head_dis));
    Q_INVARIANT_INCRIT(302, nFree == static_cast<QMPoolCtr>(~m_nFree_dis));
    #endif // ndef Q_UNSAFE
 
    // have more free blocks than the requested margin?
    if (nFree > static_cast<QMPoolCtr>(margin)) {
        Q_ASSERT_INCRIT(310, fb != nullptr);
 
        QFreeBlock * const fb_next = fb->m_next;
 
    #ifndef Q_UNSAFE
        // the free block must have integrity (duplicate inverse storage)
        Q_INVARIANT_INCRIT(311, Q_PTR2UINT_CAST_(fb_next)
            == static_cast<std::uintptr_t>(~fb->m_next_dis));
    #endif // ndef Q_UNSAFE
 
        --nFree; // one less free block
        if (nFree == 0U) { // is the pool becoming empty?
            // pool is becoming empty, so the next free block must be NULL
            Q_ASSERT_INCRIT(320, fb_next == nullptr);
 
            m_nFree = 0U;
    #ifndef Q_UNSAFE
            m_nFree_dis = static_cast<QMPoolCtr>(~m_nFree);
            m_nMin = 0U; // remember that the pool got empty
    #endif // ndef Q_UNSAFE
        }
        else {
            m_nFree = nFree; // update the original
    #ifndef Q_UNSAFE
            m_nFree_dis = static_cast<QMPoolCtr>(~nFree);
 
            // The pool is not empty, so the next free-block pointer
            // must be in range.
            Q_INVARIANT_INCRIT(330,
                QF_PTR_RANGE_(fb_next, m_start, m_end));
 
            // is the # free blocks the new minimum so far?
            if (m_nMin > nFree) {
                m_nMin = nFree; // remember the minimum so far
            }
    #endif // ndef Q_UNSAFE
        }
 
        m_free_head = fb_next; // set the head to the next free block
    #ifndef Q_UNSAFE
        m_free_head_dis =
            static_cast<std::uintptr_t>(~Q_PTR2UINT_CAST_(fb_next));
    #endif // ndef Q_UNSAFE
 
        QS_BEGIN_PRE(QS_QF_MPOOL_GET, qsId)
            QS_TIME_PRE();         // timestamp
            QS_OBJ_PRE(this);      // this memory pool
            QS_MPC_PRE(nFree);     // # of free blocks in the pool
    #ifndef Q_UNSAFE
            QS_MPC_PRE(m_nMin);    // min # free blocks ever in the pool
    #else
            QS_MPC_PRE(0U);        // min # free blocks (not available)
    #endif // ndef Q_UNSAFE
        QS_END_PRE()
    }
    else { // don't have enough free blocks at this point
        fb = nullptr;
 
        QS_BEGIN_PRE(QS_QF_MPOOL_GET_ATTEMPT, qsId)
            QS_TIME_PRE();         // timestamp
            QS_OBJ_PRE(this);      // this memory pool
            QS_MPC_PRE(nFree);     // # of free blocks in the pool
            QS_MPC_PRE(margin);    // the requested margin
        QS_END_PRE()
    }
 
    QF_MEM_APP();
    QF_CRIT_EXIT();
 
    return fb; // return the block or nullptr to the caller
}
 
//${QF::QMPool::put} .........................................................
void QMPool::put(
    void * const block,
    std::uint_fast8_t const qsId) noexcept
{
    #ifndef Q_SPY
    Q_UNUSED_PAR(qsId);
    #endif
 
    QFreeBlock * const fb = static_cast<QFreeBlock *>(block);
 
    QF_CRIT_STAT
    QF_CRIT_ENTRY();
    QF_MEM_SYS();
 
    // get volatile into temporaries
    QFreeBlock * const free_head = m_free_head;
    QMPoolCtr nFree = m_nFree;
 
    #ifndef Q_UNSAFE
    Q_INVARIANT_INCRIT(401, Q_PTR2UINT_CAST_(free_head)
        == static_cast<std::uintptr_t>(~m_free_head_dis));
    Q_INVARIANT_INCRIT(402, nFree == static_cast<QMPoolCtr>(~m_nFree_dis));
 
    Q_REQUIRE_INCRIT(410, nFree < m_nTot);
    Q_REQUIRE_INCRIT(411, QF_PTR_RANGE_(fb, m_start, m_end));
 
    // the block must not be in the pool already
    Q_REQUIRE_INCRIT(412, Q_PTR2UINT_CAST_(fb->m_next)
        != static_cast<std::uintptr_t>(~fb->m_next_dis));
    #endif // ndef Q_UNSAFE
 
    ++nFree; // one more free block in this pool
 
    m_free_head = fb; // set as new head of the free list
    m_nFree     = nFree;
    fb->m_next  = free_head; // link into the list
    #ifndef Q_UNSAFE
    m_free_head_dis = static_cast<std::uintptr_t>(~Q_PTR2UINT_CAST_(fb));
    m_nFree_dis     = static_cast<QMPoolCtr>(~nFree);
    fb->m_next_dis  = static_cast<std::uintptr_t>(~Q_PTR2UINT_CAST_(free_head));
    #endif
 
    QS_BEGIN_PRE(QS_QF_MPOOL_PUT, qsId)
        QS_TIME_PRE();         // timestamp
        QS_OBJ_PRE(this);      // this memory pool
        QS_MPC_PRE(nFree);     // the # free blocks in the pool
    QS_END_PRE()
 
    QF_MEM_APP();
    QF_CRIT_EXIT();
}
 
//${QF::QMPool::getBlockSize} ................................................
QMPoolSize QMPool::getBlockSize() const noexcept {
    return m_blockSize;
}
 
} // namespace QP
//$enddef${QF::QMPool} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^