Update DelegateMQ library

Author: endurodave

DelegateMQ/DelegateMQ.h

@@ -84,6 +84,7 @@
 // Valid for any platform where a Mutex is defined in DelegateOpt.h
 #if defined(DMQ_THREAD_STDLIB) || \
     defined(DMQ_THREAD_WIN32) || \
+    defined(DMQ_THREAD_POSIX) || \
     defined(DMQ_THREAD_FREERTOS) || \
     defined(DMQ_THREAD_THREADX) || \
     defined(DMQ_THREAD_ZEPHYR) || \
@@ -104,6 +105,7 @@
 // Valid for any platform that implements the IThread interface
 #if defined(DMQ_THREAD_STDLIB) || \
     defined(DMQ_THREAD_WIN32) || \
+    defined(DMQ_THREAD_POSIX) || \
     defined(DMQ_THREAD_FREERTOS) || \
     defined(DMQ_THREAD_THREADX) || \
     defined(DMQ_THREAD_ZEPHYR) || \
@@ -133,6 +135,9 @@
 #elif defined(DMQ_THREAD_WIN32)
     #include "port/os/win32/Win32Thread.h"
     #include "port/os/common/ThreadMsg.h"
+#elif defined(DMQ_THREAD_POSIX)
+    #include "port/os/posix/PosixThread.h"
+    #include "port/os/common/ThreadMsg.h"
 #elif defined(DMQ_THREAD_FREERTOS)
     #include "port/os/freertos/FreeRTOSThread.h"
     #include "port/os/common/ThreadMsg.h"

DelegateMQ/Port.cmake

@@ -9,8 +9,14 @@ if (DMQ_THREAD STREQUAL "DMQ_THREAD_STDLIB")
 elseif (DMQ_THREAD STREQUAL "DMQ_THREAD_WIN32")
     add_compile_definitions(DMQ_THREAD_WIN32)
     file(GLOB THREAD_SOURCES CONFIGURE_DEPENDS
-        "${DMQ_ROOT_DIR}/port/os/win32/*.c*" 
-        "${DMQ_ROOT_DIR}/port/os/win32/*.h" 
+        "${DMQ_ROOT_DIR}/port/os/win32/*.c*"
+        "${DMQ_ROOT_DIR}/port/os/win32/*.h"
+    )
+elseif (DMQ_THREAD STREQUAL "DMQ_THREAD_POSIX")
+    add_compile_definitions(DMQ_THREAD_POSIX)
+    file(GLOB THREAD_SOURCES CONFIGURE_DEPENDS
+        "${DMQ_ROOT_DIR}/port/os/posix/*.c*"
+        "${DMQ_ROOT_DIR}/port/os/posix/*.h"
     )
 elseif (DMQ_THREAD STREQUAL "DMQ_THREAD_FREERTOS")
     add_compile_definitions(DMQ_THREAD_FREERTOS)

DelegateMQ/delegate/DelegateMQConfig_Default.h

@@ -25,6 +25,17 @@
     #define DMQ_DEFAULT_QUEUE_SIZE          20
 #endif
 
+// Fallback queue size (maxQueueSize == 0) for the desktop stdlib/Win32 Thread ports
+// only. Unlike DMQ_DEFAULT_QUEUE_SIZE (sized for real RTOS RAM constraints), these
+// ports back their queue with a plain std::deque, so maxQueueSize == 0 otherwise
+// means genuinely unbounded growth if the destination thread is dead/stuck. This
+// is a high-water-mark safety net, not a throughput limiter -- large enough to
+// never interfere with normal desktop bursts, but bounded so a truly dead consumer
+// hits a clear FullPolicy::FAULT instead of growing the heap without limit.
+#ifndef DMQ_THREAD_DESKTOP_QUEUE_SIZE
+    #define DMQ_THREAD_DESKTOP_QUEUE_SIZE   1000
+#endif
+
 #ifndef DMQ_MAX_WATCHDOG_THREADS
     #define DMQ_MAX_WATCHDOG_THREADS        16
 #endif

DelegateMQ/delegate/DelegateMQConfig_Template.h

@@ -20,9 +20,17 @@
 /// Signals with <= this many subscribers are invoked without heap allocation.
 #define DMQ_SIGNAL_SBO_COUNT            8
 
-/// Default internal message queue depth for all dmq::os::Thread ports.
+/// Default internal message queue depth (maxQueueSize == 0) for the RTOS
+/// dmq::os::Thread ports (FreeRTOS, Zephyr, ThreadX, CMSIS-RTOS2, NuttX), where
+/// the backing queue primitive requires a fixed capacity at creation.
 #define DMQ_DEFAULT_QUEUE_SIZE          20
 
+/// Fallback queue size (maxQueueSize == 0) for the desktop stdlib/Win32 Thread
+/// ports only. A high-water-mark safety net (not a throughput limiter) against
+/// unbounded growth if the destination thread is dead/stuck -- large enough to
+/// never interfere with normal desktop bursts.
+#define DMQ_THREAD_DESKTOP_QUEUE_SIZE   1000
+
 /// Max number of threads that can be registered with the watchdog.
 #define DMQ_MAX_WATCHDOG_THREADS        16
 

DelegateMQ/delegate/DelegateOpt.h

@@ -29,7 +29,7 @@
 
 // --- PLATFORM AUTO-DETECTION ---
 // If no threading model is defined, attempt to auto-select a default
-#if !defined(DMQ_THREAD_STDLIB) && !defined(DMQ_THREAD_WIN32) && \
+#if !defined(DMQ_THREAD_STDLIB) && !defined(DMQ_THREAD_WIN32) && !defined(DMQ_THREAD_POSIX) && \
     !defined(DMQ_THREAD_FREERTOS) && !defined(DMQ_THREAD_THREADX) && \
     !defined(DMQ_THREAD_ZEPHYR) && !defined(DMQ_THREAD_CMSIS_RTOS2) && \
     !defined(DMQ_THREAD_NUTTX) && \
@@ -72,9 +72,10 @@
 // True when a real thread model is configured (desktop or embedded RTOS),
 // as opposed to DMQ_THREAD_NONE or no thread model at all (bare metal,
 // single-threaded). Named once here instead of hand-copying this same
-// 7-macro list at every call site that needs to know whether Mutex/
+// 8-macro list at every call site that needs to know whether Mutex/
 // ConditionVariable/std::thread-equivalent support exists.
 #if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT) || \
+    defined(DMQ_THREAD_POSIX) || \
     defined(DMQ_THREAD_FREERTOS) || defined(DMQ_THREAD_THREADX) || \
     defined(DMQ_THREAD_ZEPHYR) || defined(DMQ_THREAD_CMSIS_RTOS2) || \
     defined(DMQ_THREAD_NUTTX)
@@ -168,8 +169,10 @@
 // later #include "extras/util/Fault.h" below is a harmless no-op.
 #include "extras/util/Fault.h"
 
-#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT)
-    // Windows / Linux / macOS / Qt (Standard Library)
+#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT) || defined(DMQ_THREAD_POSIX)
+    // Windows / Linux / macOS / Qt (Standard Library) / POSIX (raw pthreads,
+    // but Mutex/ConditionVariable/Clock/ThisThread still reuse std:: here --
+    // see port/os/posix/PosixThread.h, the only file this port adds)
     #include <condition_variable>
     #include <thread>
 #elif defined(DMQ_THREAD_FREERTOS)
@@ -249,8 +252,8 @@ namespace dmq
     // @TODO: Change aliases to switch clock type globally if necessary
 
     // --- CLOCK SELECTION ---
-#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT)
-    // Windows / Linux / macOS / Qt
+#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT) || defined(DMQ_THREAD_POSIX)
+    // Windows / Linux / macOS / Qt / POSIX
     using Clock = std::chrono::steady_clock;
 
 #elif defined(DMQ_THREAD_FREERTOS)
@@ -296,8 +299,8 @@ namespace dmq
     // std;` together, and a same-named nested namespace would make unqualified
     // this_thread::sleep_for() calls in that code ambiguous against
     // std::this_thread.
-#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT)
-    // Windows / Linux / macOS / Qt -- std::this_thread is already portable here.
+#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT) || defined(DMQ_THREAD_POSIX)
+    // Windows / Linux / macOS / Qt / POSIX -- std::this_thread is already portable here.
     struct ThisThread {
         template<typename Rep, typename Period>
         static void sleep_for(std::chrono::duration<Rep, Period> d) { std::this_thread::sleep_for(d); }
@@ -362,7 +365,10 @@ namespace dmq
 #endif
 
     /// @brief Policy applied when a dmq::os::Thread port's message queue is full.
-    /// @details Only meaningful when the port's maxQueueSize > 0.
+    /// @details Always enforced -- a constructor's maxQueueSize == 0 is a sentinel meaning
+    /// "use this port's default capacity" (dmq::DEFAULT_QUEUE_SIZE for the RTOS ports,
+    /// dmq::THREAD_DESKTOP_QUEUE_SIZE for stdlib/Win32), not "disable the cap." Every port's
+    /// effective queue capacity is therefore always > 0 at runtime.
     ///   - DROP:    DispatchDelegate() silently discards the message and returns immediately.
     ///   - FAULT:   DispatchDelegate() triggers a system fault if the queue is full.
     ///   - TIMEOUT: DispatchDelegate() waits up to dispatchTimeout, then logs and drops.
@@ -389,10 +395,20 @@ namespace dmq
     /// Override via DMQ_SIGNAL_SBO_COUNT in delegatemqconfig.h.
     inline constexpr size_t SIGNAL_SBO_COUNT = DMQ_SIGNAL_SBO_COUNT;
 
-    /// @brief Default internal queue size for all dmq::os::Thread ports.
+    /// @brief Default internal queue size (maxQueueSize == 0) for the RTOS
+    /// dmq::os::Thread ports, where the backing queue primitive requires a
+    /// fixed capacity at creation.
     /// Override via DMQ_DEFAULT_QUEUE_SIZE in delegatemqconfig.h.
     inline constexpr size_t DEFAULT_QUEUE_SIZE = DMQ_DEFAULT_QUEUE_SIZE;
 
+    /// @brief Fallback queue size (maxQueueSize == 0) for the desktop
+    /// stdlib/Win32 Thread ports only, which back their queue with a plain
+    /// std::deque and would otherwise grow without bound if the destination
+    /// thread is dead/stuck. A high-water-mark safety net, not a throughput
+    /// limiter -- large enough to never interfere with normal desktop bursts.
+    /// Override via DMQ_THREAD_DESKTOP_QUEUE_SIZE in delegatemqconfig.h.
+    inline constexpr size_t THREAD_DESKTOP_QUEUE_SIZE = DMQ_THREAD_DESKTOP_QUEUE_SIZE;
+
     /// @brief Max number of threads that can be monitored by the watchdog.
     /// Override via DMQ_MAX_WATCHDOG_THREADS in delegatemqconfig.h.
     inline constexpr size_t MAX_WATCHDOG_THREADS = DMQ_MAX_WATCHDOG_THREADS;
@@ -430,8 +446,8 @@ namespace dmq
     inline constexpr size_t MAX_TRANSPORT_MONITOR_PENDING = DMQ_TRANSPORT_MONITOR_MAX_PENDING;
 
     // --- MUTEX / LOCK SELECTION ---
-#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT)
-    // Windows / Linux / macOS / Qt
+#if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT) || defined(DMQ_THREAD_POSIX)
+    // Windows / Linux / macOS / Qt / POSIX
     using Mutex = std::mutex;
     using RecursiveMutex = std::recursive_mutex;
     // No ISR concept reachable from userspace on desktop OSes, and
@@ -482,15 +498,13 @@ namespace dmq
     using Mutex = dmq::os::ZephyrMutex;
     using RecursiveMutex = dmq::os::ZephyrRecursiveMutex;
     // ISR-safe (irq_lock()/irq_unlock(key), not a k_mutex) -- see
-    // ZephyrCriticalSection.h. UNVERIFIED: no Zephyr SDK/west workspace is
-    // available in this development environment to build and run it; review
-    // before relying on it in production.
+    // ZephyrCriticalSection.h.
     using CriticalSection = dmq::os::ZephyrCriticalSection;
     // No dmq::ConditionVariable port for Zephyr (no DMQ_HAS_CV), but
     // dmq::Semaphore is available via Zephyr's own native k_sem instead of
     // the generic condvar+mutex implementation -- see ZephyrSemaphore.h and
     // delegate/Semaphore.h. This is what makes DelegateAsyncWait available
-    // here. UNVERIFIED, same caveat as CriticalSection above.
+    // here.
     using Semaphore = dmq::os::ZephyrSemaphore;
     #define DMQ_HAS_SEMAPHORE
     template<typename T> using LockGuard = PortableLockGuard<T>;
@@ -508,8 +522,7 @@ namespace dmq
     // native condvar primitive to build one from), but dmq::Semaphore is
     // available via osSemaphore directly instead -- see
     // CmsisRtos2Semaphore.h and delegate/Semaphore.h. This is what makes
-    // DelegateAsyncWait available here. UNVERIFIED, same caveat as
-    // CriticalSection above.
+    // DelegateAsyncWait available here.
     using Semaphore = dmq::os::CmsisRtos2Semaphore;
     #define DMQ_HAS_SEMAPHORE
     template<typename T> using LockGuard = PortableLockGuard<T>;
@@ -523,16 +536,14 @@ namespace dmq
     // ISR-safe (up_irq_save()/up_irq_restore(), NuttX's own architecture-
     // portable interrupt-masking primitive, not a pthread_mutex_t) -- see
     // NuttXCriticalSection.h, including its FLAT-vs-PROTECTED/KERNEL-build
-    // caveat. UNVERIFIED: no NuttX toolchain/simulator is available in this
-    // development environment to build and run it; review before relying
-    // on it in production.
+    // caveat.
     using CriticalSection = dmq::os::NuttXCriticalSection;
     // No dmq::ConditionVariable port for NuttX (no DMQ_HAS_CV) -- not
     // because NuttX lacks pthread_cond_t (it has a real one), but because
     // dmq::Semaphore is available via NuttX's own native sem_t instead of
     // the generic condvar+mutex implementation -- see NuttXSemaphore.h and
     // delegate/Semaphore.h. This is what makes DelegateAsyncWait available
-    // here. UNVERIFIED, same caveat as CriticalSection above.
+    // here.
     using Semaphore = dmq::os::NuttXSemaphore;
     #define DMQ_HAS_SEMAPHORE
     template<typename T> using LockGuard = PortableLockGuard<T>;