Improve TimerHost::PushCommand() tolerance to multiple CMD_RESTART, CMD_START_OR_RESET commands which could be issued by ISR (e.g. debouncing button) within the kernel's tick period.

Cleanup TimerHost implementation.
Replace STK_ALLOCATE_COUNT macro with template meta-programming.
Wrap memcpy with re-definable STK_MEMCPY.

Author: dmitrykos

stk/include/stk.h

@@ -648,10 +648,10 @@ final
         Stack             m_stack;      //!< Stack descriptor (SP register value + access mode + optional tid).
         volatile uint32_t m_state;      //!< Bitmask of EStateFlags. Written by task thread, read/cleared by kernel tick.
         volatile Timeout  m_time_sleep; //!< Sleep countdown: negative while sleeping (absolute value = ticks remaining), zero when awake.
-        SrtInfo           m_srt[STK_ALLOCATE_COUNT(TMode, KERNEL_HRT, 0, 1)];       //!< SRT metadata. Zero-size (no memory) in KERNEL_HRT mode.
-        HrtInfo           m_hrt[STK_ALLOCATE_COUNT(TMode, KERNEL_HRT, 1, 0)];       //!< HRT metadata. Zero-size (no memory) in non-HRT mode.
-        Weight            m_rt_weight[STK_ALLOCATE_COUNT(TStrategy::WEIGHT_API, 1, 1, 0)]; //!< Run-time weight for weighted-round-robin scheduling. Zero-size for unweighted strategies.
-        WaitObject        m_wait_obj[STK_ALLOCATE_COUNT(TMode, KERNEL_SYNC, 1, 0)]; //!< Embedded wait object for synchronization. Zero-size (no memory) if KERNEL_SYNC is not set.
+        SrtInfo           m_srt[STK_ALLOCATE_COUNT<TMode, KERNEL_HRT, 0U, 1U>::Value];       //!< SRT metadata. Zero-size (no memory) in KERNEL_HRT mode.
+        HrtInfo           m_hrt[STK_ALLOCATE_COUNT<TMode, KERNEL_HRT, 1U, 0U>::Value];       //!< HRT metadata. Zero-size (no memory) in non-HRT mode.
+        Weight            m_rt_weight[STK_ALLOCATE_COUNT<TStrategy::WEIGHT_API, 1U, 1U, 0U>::Value]; //!< Run-time weight for weighted-round-robin scheduling. Zero-size for unweighted strategies.
+        WaitObject        m_wait_obj[STK_ALLOCATE_COUNT<TMode, KERNEL_SYNC, 1U, 0U>::Value]; //!< Embedded wait object for synchronization. Zero-size (no memory) if KERNEL_SYNC is not set.
     };
 
     /*! \class KernelService
@@ -2226,11 +2226,11 @@ final
     KernelTask      *m_task_now;        //!< Currently executing task, or \c nullptr before Start() or after all tasks exit.
     TaskStorageType  m_task_storage;    //!< Static pool of TSize KernelTask slots (free slots have m_user == nullptr).
     SleepTrapStack   m_sleep_trap[1];   //!< Sleep trap (always present): executed when all tasks are sleeping.
-    ExitTrapStack    m_exit_trap[STK_ALLOCATE_COUNT(TMode, KERNEL_DYNAMIC, 1, 0)]; //!< Exit trap: zero-size in KERNEL_STATIC mode; one entry in KERNEL_DYNAMIC mode.
+    ExitTrapStack    m_exit_trap[STK_ALLOCATE_COUNT<TMode, KERNEL_DYNAMIC, 1U, 0U>::Value]; //!< Exit trap: zero-size in KERNEL_STATIC mode; one entry in KERNEL_DYNAMIC mode.
     EFsmState        m_fsm_state;       //!< Current FSM state. Drives context-switch decision on every tick.
     volatile uint8_t m_request;         //!< Bitmask of pending ERequest flags from running tasks. Written by tasks, read/cleared by UpdateTaskRequest() in tick context.
     volatile EState  m_state;           //!< Current kernel state.
-    SyncObjectList   m_sync_list[STK_ALLOCATE_COUNT(TMode, KERNEL_SYNC, 1, 0)]; //!< List of active sync objects. Zero-size (no memory) if KERNEL_SYNC is not set.
+    SyncObjectList   m_sync_list[STK_ALLOCATE_COUNT<TMode, KERNEL_SYNC, 1U, 0U>::Value]; //!< List of active sync objects. Zero-size (no memory) if KERNEL_SYNC is not set.
 
     const EFsmState  m_fsm[FSM_STATE_MAX][FSM_EVENT_MAX] = {
     //    FSM_EVENT_SWITCH     FSM_EVENT_SLEEP     FSM_EVENT_WAKE    FSM_EVENT_EXIT

stk/include/stk_defs.h

@@ -521,23 +521,28 @@
     #define STK_SLEEP_TRAP_STACK_SIZE (STK_STACK_SIZE_MIN)
 #endif
 
-/*! \def   STK_ALLOCATE_COUNT
-    \brief Selects a static array element count at compile time based on a mode flag.
-    \note  On GCC/Clang: expands to ONTRUE if (MODE & FLAG) is non-zero, otherwise ONFALSE.
-           On MSVC/IAR: always expands to max(ONTRUE, ONFALSE) because these compilers do not support
-           zero-sized arrays. This means MSVC and IAR builds may over-allocate when the flag is not set,
-           but avoids a compile error. Configuration mistakes that would result in ONFALSE on other 
-           compilers will be silently masked.
-    \param[in] MODE: Bitmask of active kernel modes (e.g. EKernelMode flags).
-    \param[in] FLAG: The specific mode bit to test.
-    \param[in] ONTRUE: Array count to use when FLAG is active.
-    \param[in] ONFALSE: Array count to use when FLAG is inactive (may be 0 on GCC/Clang).
-*/
+/*! \struct STK_ALLOCATE_COUNT
+    \brief  Selects a static array element count at compile time based on a mode flag.
+    \note   On GCC/Clang: evaluates to ONTRUE if (MODE & FLAG) is non-zero, otherwise ONFALSE.
+            On MSVC/IAR: always evaluates to the maximum of ONTRUE and ONFALSE because these
+            compilers do not support zero-sized arrays.
+
+    \tparam MODE    Bitmask of active kernel modes (e.g., EKernelMode flags).
+    \tparam FLAG    The specific mode bit to test.
+    \tparam ONTRUE  Array count to use when FLAG is active.
+    \tparam ONFALSE Array count to use when FLAG is inactive (may be 0 on GCC/Clang).
+*/
+template <size_t MODE, size_t FLAG, size_t ONTRUE, size_t ONFALSE>
+struct STK_ALLOCATE_COUNT
+{
 #if defined(_MSC_VER) || defined(__ICCARM__)
-    #define STK_ALLOCATE_COUNT(MODE, FLAG, ONTRUE, ONFALSE) ((ONTRUE) > (ONFALSE) ? (ONTRUE) : (ONFALSE))
+    /* MSVC and IAR builds may over-allocate when the flag is not set to avoid compile errors. */
+    static constexpr size_t Value = ((ONTRUE > ONFALSE) ? ONTRUE : ONFALSE);
 #else
-    #define STK_ALLOCATE_COUNT(MODE, FLAG, ONTRUE, ONFALSE) ((((MODE) & (FLAG)) != 0U) ? (ONTRUE) : (ONFALSE))
+    /* GCC and Clang support zero-sized array extensions natively. */
+    static constexpr size_t Value = (((MODE & FLAG) != 0U) ? ONTRUE : ONFALSE);
 #endif
+};
 
 /*! \def   STK_ENDIAN_IDX_HI
     \brief Array index of the high 32-bit word when a 64-bit value is viewed as \c uint32_t[2].
@@ -577,6 +582,18 @@
 */
 #define STK_UNUSED(X) static_cast<void>(X)
 
+/*! \brief     A wrapper for a built-in memcpy, redefine to your own if required.
+    \note      Can be overridden by defining _STK_CUSTOM_MEMCPY in system configuration.
+*/
+#ifndef _STK_CUSTOM_MEMCPY
+#include <string.h>
+static __stk_forceinline void STK_MEMCPY(void *const dest, const void *const src, const size_t size)
+{
+    /* MISRA-compliant explicitly-typed call to underlying implementation */
+    static_cast<void>(memcpy(dest, src, size));
+}
+#endif
+
 /*! \namespace stk
     \brief     Namespace of STK package.
  */

stk/include/strategy/stk_strategy_edf.h

@@ -79,8 +79,7 @@ class SwitchStrategyEDF final : public ITaskSwitchStrategy
     /*! \brief Destructor.
         \note  MISRA deviation: [STK-DEV-005] Rule 10-3-2.
     */
-    ~SwitchStrategyEDF()
-    {}
+    ~SwitchStrategyEDF() = default;
 
     /*! \brief     Add task to the runnable set.
         \param[in] task: Task to add. Must not be \c NULL and must not already be in any list.

stk/include/strategy/stk_strategy_fpriority.h

@@ -100,8 +100,7 @@ class SwitchStrategyFixedPriority final : public ITaskSwitchStrategy
     /*! \brief Destructor.
         \note  MISRA deviation: [STK-DEV-005] Rule 10-3-2.
     */
-    ~SwitchStrategyFixedPriority()
-    {}
+    ~SwitchStrategyFixedPriority() = default;
 
     /*! \brief     Add task to the runnable set at its fixed priority level.
         \param[in] task: Task to add. Must not be \c NULL and must not already be in any list.

stk/include/strategy/stk_strategy_monotonic.h

@@ -88,8 +88,7 @@ class SwitchStrategyMonotonic final : public ITaskSwitchStrategy
     /*! \brief Destructor.
         \note  MISRA deviation: [STK-DEV-005] Rule 10-3-2.
     */
-    ~SwitchStrategyMonotonic()
-    {}
+    ~SwitchStrategyMonotonic() = default;
 
     /*! \brief     Add a task to the priority-sorted runnable list.
         \param[in] task: Task to add. Must not be \c NULL and must not already be in any list.

stk/include/strategy/stk_strategy_rrobin.h

@@ -60,8 +60,7 @@ class SwitchStrategyRoundRobin final : public ITaskSwitchStrategy
     /*! \brief Destructor.
         \note  MISRA deviation: [STK-DEV-005] Rule 10-3-2.
     */
-    ~SwitchStrategyRoundRobin()
-    {}
+    ~SwitchStrategyRoundRobin() = default;
 
     /*! \brief     Add task to the runnable set.
         \param[in] task: Task to add. Must not be \c nullptr and must not already be in any list.

stk/include/strategy/stk_strategy_swrrobin.h

@@ -81,8 +81,7 @@ class SwitchStrategySmoothWeightedRoundRobin final : public ITaskSwitchStrategy
     /*! \brief Destructor.
         \note  MISRA deviation: [STK-DEV-005] Rule 10-3-2.
     */
-    ~SwitchStrategySmoothWeightedRoundRobin()
-    {}
+    ~SwitchStrategySmoothWeightedRoundRobin() = default;
 
     /*! \brief     Add task to the runnable set.
         \param[in] task: Task to add. Must not be \c nullptr.

stk/include/sync/stk_sync_msgqueue.h

@@ -334,7 +334,7 @@ inline bool MessageQueue::Put(const void *msg_ptr, Timeout timeout)
             return false;
     }
 
-    memcpy(Slot(m_head), msg_ptr, m_msg_size);
+    STK_MEMCPY(Slot(m_head), msg_ptr, m_msg_size);
     m_head = Next(m_head);
     m_count++;
 
@@ -364,7 +364,7 @@ inline bool MessageQueue::PutFront(const void *msg_ptr, Timeout timeout)
     // then write the message there.  This makes the new message the head of
     // the logical sequence without touching m_head at all.
     m_tail = Prev(m_tail);
-    memcpy(Slot(m_tail), msg_ptr, m_msg_size);
+    STK_MEMCPY(Slot(m_tail), msg_ptr, m_msg_size);
     m_count++;
 
     m_cv_not_empty.NotifyOne_CS();
@@ -415,7 +415,7 @@ inline bool MessageQueue::Peek(void *msg_ptr, Timeout timeout)
 
     // Copy from the tail slot without advancing the index or decrementing
     // the count, so the message remains available for the next Get().
-    memcpy(msg_ptr, Slot(m_tail), m_msg_size);
+    STK_MEMCPY(msg_ptr, Slot(m_tail), m_msg_size);
 
     return true;
 }
@@ -439,7 +439,7 @@ inline bool MessageQueue::PeekFront(void *msg_ptr, Timeout timeout)
     // The front-inserted message is at m_tail (PutFront retreats m_tail then
     // writes, so the newly placed message is always at the current m_tail).
     // For a pure-Put queue this is equally correct: m_tail is the oldest slot.
-    memcpy(msg_ptr, Slot(m_tail), m_msg_size);
+    STK_MEMCPY(msg_ptr, Slot(m_tail), m_msg_size);
 
     return true;
 }

stk/include/sync/stk_sync_rwmutex.h

@@ -10,8 +10,6 @@
 #ifndef STK_SYNC_RWMUTEX_H_
 #define STK_SYNC_RWMUTEX_H_
 
-#include "stk_common.h"
-#include "stk_sync_cs.h"
 #include "stk_sync_cv.h"
 
 /*! \file  stk_sync_rwmutex.h

stk/include/sync/stk_sync_spinlock.h

@@ -10,7 +10,7 @@
 #ifndef STK_SYNC_SPINLOCK_H_
 #define STK_SYNC_SPINLOCK_H_
 
-#include "stk_common.h"
+#include "stk_helper.h"
 
 /*! \file  stk_sync_spinlock.h
     \brief Implementation of synchronization primitive: stk::sync::SpinLock.