update to qpcpp v7.2.1

Author: mattheweshleman

README.md

@@ -55,7 +55,10 @@ be compatible with this code.
 * qpcpp (pulled in as a git submodule)
   * After cloning this repository, do not forget to:
   * `git submodule init`
-  * `git submodule update`
+  * `git submodule update --recursive`
+  * NOTE: As of January 2023, qpcpp is also using submodules. Developers
+    may need to perform similar steps within the externals/qpcpp/ 
+    directory as well.
 * CppUTest (version 3.8-7, the default in Ubuntu 20.04)
 * CMake and associated build tools were used to develop
   and prove out this project.

examples/hwLockCtrlService/include/hwLockCtrlService.hpp

@@ -47,7 +47,7 @@ class Service final : public QP::QActive {
     enum DirectSignals { PING = PubSub::MAX_PUB_SIG, MAX_DIRECT_SIG };
 
     Service();
-    ~Service() override                = default;
+    ~Service()                         = default;
 
     Service(const Service&)            = delete;
     Service& operator=(const Service&) = delete;

test_support/cpputest-qpcpp-port/include/cmsTestPublishedEventRecorder.hpp

@@ -141,7 +141,7 @@ class PublishedEventRecorder final : public DefaultDummyActiveObject {
             }
             else {
                 // record the event
-                m_recordedEvents.post(e, QP::QF_NO_MARGIN, 0);
+                m_recordedEvents.post(e, QP::QF::NO_MARGIN, 0);
             }
         }
     }

test_support/cpputest-qpcpp-port/include/qf_port.hpp

@@ -38,11 +38,16 @@
 #ifndef QF_PORT_HPP
 #define QF_PORT_HPP
 
+// provide QP::QHsm virtual destructor
+#define Q_HSM_XTOR 1
+
 // event queue and thread types
 #define QF_EQUEUE_TYPE       QEQueue
 // QF_OS_OBJECT_TYPE  not used
 // QF_THREAD_TYPE     not used
 
+#define QF_EPOOL_TYPE_ QMPool
+
 // The maximum number of active objects in the application
 #define QF_MAX_ACTIVE        64U
 
@@ -69,7 +74,6 @@
 #include "qep_port.hpp"  // QEP port
 #include "qequeue.hpp"   // POSIX-QV needs event-queue
 #include "qmpool.hpp"    // POSIX-QV needs memory-pool
-#include "qpset.hpp"     // POSIX-QV needs priority-set
 #include "qf.hpp"        // QF platform-independent public interface
 
 namespace QP {

test_support/cpputest-qpcpp-port/src/cms_cpputest_qf_ctrl.cpp

@@ -30,6 +30,7 @@
 #include <cstdint>
 #include <vector>
 #include "CppUTest/TestHarness.h"
+#include "qf_pkg.hpp"
 
 namespace cms {
 namespace test {
@@ -99,6 +100,8 @@ void Teardown()
 
     l_ticksPerSecond = 0;
 
+    QF::stop();
+
     // No test should complete with allocated events sitting
     // in a memory pool. However, the QP Pool class
     // is rather private. Ideally that
@@ -107,7 +110,13 @@ void Teardown()
     // internally will perform the memory check, as it has
     // friend access.
     if (l_memPoolOption == MemPoolTeardownOption::CHECK_FOR_LEAKS) {
-        QF::stop();
+        for (size_t i = 0; i < l_pubSubEventMemPoolConfigs->size(); ++i) {
+
+            const size_t poolNumOfEvents = l_pubSubEventMemPoolConfigs->at(i).config.numberOfEvents;
+
+            CHECK_TRUE_TEXT(poolNumOfEvents == QP::QF::ePool_[i].getNFree(),
+                            "A leak was detected in an internal QF event pool!")
+        }
     }
 
     if (l_pubSubEventMemPoolConfigs != nullptr) {
@@ -137,7 +146,7 @@ void MoveTimeForward(const std::chrono::milliseconds& duration)
       ONCE, static_cast<LoopCounter_t>(duration.count() / millisecondsPerTick));
 
     for (LoopCounter_t i = 0; i < ticks; ++i) {
-        QP::QF::tickX_(0U);
+        QP::QTimeEvt::tick_(0, nullptr);
         ProcessEvents();
     }
 }

test_support/cpputest-qpcpp-port/src/cms_cpputest_qf_onCleanup.cpp

@@ -1,18 +1,10 @@
-
-#include "CppUTest/TestHarness.h"
 #include "qpcpp.hpp"
 
 namespace QP {
 
-extern QMPool QF_pool_[QF_MAX_EPOOL];
-extern std::uint_fast8_t QF_maxPool_;
-
 void QF::onCleanup()
 {
-    for (int i = 0; i < QF_maxPool_; ++i) {
-        CHECK_TRUE_TEXT(QF_pool_[i].m_nTot == QF_pool_[i].m_nFree,
-                        "A leak was detected in an internal QF event pool!")
-    }
+    //Event pool leak detection moved, nothing to do here now.
 }
 
 }   // namespace QP

test_support/cpputest-qpcpp-port/src/cpputest_qf_port.cpp

@@ -26,10 +26,9 @@ QPSet cpputest_readySet_;   // ready set of active objects
 //****************************************************************************
 void QF::init()
 {
-    QF_maxPool_ = static_cast<uint_fast8_t>(0);
-    bzero(&QF::timeEvtHead_[0],
-          static_cast<uint_fast16_t>(sizeof(QF::timeEvtHead_)));
-    bzero(&active_[0], static_cast<uint_fast16_t>(sizeof(active_)));
+    QF::maxPool_ = static_cast<uint_fast8_t>(0);
+    bzero(&QP::QTimeEvt::timeEvtHead_[0], sizeof(QP::QTimeEvt::timeEvtHead_));
+    bzero(&QP::QActive::registry_[0], sizeof(QP::QActive::registry_));
 }
 
 #if PURPOSEFULLY_NOT_IMPLEMENTED_
@@ -44,7 +43,7 @@ void QF_runUntilNoReadyActiveObjects()
 {
     while (cpputest_readySet_.notEmpty()) {
         std::uint_fast8_t p = cpputest_readySet_.findMax();
-        QActive* a          = QF::active_[p];
+        QActive* a          = QP::QActive::registry_[p];
 
         // the active object 'a' must still be registered in QF
         // (e.g., it must not be stopped)
@@ -57,7 +56,7 @@ void QF_runUntilNoReadyActiveObjects()
         }
 
         if (a->m_eQueue.isEmpty()) { /* empty queue? */
-            cpputest_readySet_.rmove(p);
+            cpputest_readySet_.remove(p);
         }
     }
 }
@@ -69,32 +68,32 @@ void QF::stop()
 }
 
 //****************************************************************************
-void QActive::start(std::uint_fast8_t const priority, QEvt const** const qSto,
-                    std::uint_fast16_t const qLen, void* const stkSto,
-                    std::uint_fast16_t const stkSize, void const* const par)
+void QActive::start( QPrioSpec const prioSpec,
+                    QEvt const * * const qSto, std::uint_fast16_t const qLen,
+                    void * const stkSto, std::uint_fast16_t const stkSize,
+                    void const * const par)
 {
-    (void)stkSize;   // unused parameter in the cpputest port
+    // unused parameters in the cpputest port
+    Q_UNUSED_PAR(stkSto);
+    Q_UNUSED_PAR(stkSize);
 
-    Q_REQUIRE_ID(
-      600, (0U < priority)                  /* priority...*/
-             && (priority <= QF_MAX_ACTIVE) /*.. in range */
-             && (stkSto == nullptr));   // stack storage must NOT be provided
-    m_eQueue.init(qSto, qLen);
+    m_prio  = static_cast<std::uint8_t>(prioSpec & 0xFFU); // QF-priority
+    m_pthre = static_cast<std::uint8_t>(prioSpec >> 8U); // preemption-thre.
+    register_(); // make QF aware of this AO
 
-    m_prio =
-      static_cast<std::uint8_t>(priority);   // set the QF priority of this AO
-    QF::add_(this);                          // make QF aware of this AO
+    m_eQueue.init(qSto, qLen);
 
-    this->init(par, m_prio);   // execute initial transition (virtual call)
+    this->init(par, m_prio); // execute initial transition (virtual call)
+    QS_FLUSH(); // flush the QS trace buffer to the host
 }
 
 //............................................................................
 #ifdef QF_ACTIVE_STOP
 void QActive::stop()
 {
     unsubscribeAll();
-    cpputest_readySet_.rmove(m_prio);
-    QF::remove_(this);
+    cpputest_readySet_.remove(m_prio);
+    unregister_();
 }
 #endif
 

test_support/cpputest-qpcpp-port/test/cms_cpputest_qf_ctrlTests.cpp

@@ -25,11 +25,7 @@
 #include "cms_cpputest_qf_ctrl.hpp"
 #include "qpcpp.hpp"
 #include "CppUTest/TestHarness.h"
-
-namespace QP {
-extern QMPool QF_pool_[QF_MAX_EPOOL];
-extern std::uint_fast8_t QF_maxPool_;
-}   // namespace QP
+#include "qf_pkg.hpp"
 
 using namespace cms::test;
 
@@ -46,14 +42,14 @@ TEST_GROUP(qf_ctrlTests)
 
     void ConfirmNumberOfPools(uint32_t poolCount)
     {
-        CHECK_EQUAL(poolCount, QP::QF_maxPool_);
+        CHECK_EQUAL(poolCount, QP::QF::maxPool_);
     }
 
     void ConfirmPoolEventSize(uint32_t poolIndex, uint32_t blockSize)
     {
         CHECK_TRUE(poolIndex < QF_MAX_EPOOL);
-        CHECK_TRUE(poolIndex < QP::QF_maxPool_);
-        CHECK_EQUAL(blockSize, QP::QF_pool_[poolIndex].getBlockSize());
+        CHECK_TRUE(poolIndex < QP::QF::maxPool_);
+        CHECK_EQUAL(blockSize, QP::QF::ePool_[poolIndex].getBlockSize());
     }
 };
 

utilities/test/backedQueueTests.cpp

@@ -84,7 +84,7 @@ TEST(BackedQueueTests, can_push_up_to_max_events)
     // fill up the queue
     static QP::QEvt testEvent {5, 0, 0};
     for (size_t i = 0; i < underTest->capacity(); ++i) {
-        underTest->post(&testEvent, QP::QF_NO_MARGIN, 0);
+        underTest->post(&testEvent, QP::QF::NO_MARGIN, 0);
     }
 
     // confirm full