Update DelegateMQ library

Author: endurodave

DelegateMQ/Defaults.cmake

@@ -0,0 +1,79 @@
+# DelegateMQ Defaults
+# 
+# This module auto-selects default DelegateMQ build options based on the target platform.
+# Options can be overridden by setting the variables before including DelegateMQ.cmake.
+
+# --- Threading Defaults ---
+if(NOT DEFINED DMQ_THREAD)
+    if(WIN32 OR UNIX)
+        set(DMQ_THREAD "DMQ_THREAD_STDLIB")
+    elseif(FREERTOS OR FREE_RTOS)
+        set(DMQ_THREAD "DMQ_THREAD_FREERTOS")
+    elseif(THREADX)
+        set(DMQ_THREAD "DMQ_THREAD_THREADX")
+    elseif(ZEPHYR)
+        set(DMQ_THREAD "DMQ_THREAD_ZEPHYR")
+    elseif(CMSIS_RTOS2)
+        set(DMQ_THREAD "DMQ_THREAD_CMSIS_RTOS2")
+    else()
+        set(DMQ_THREAD "DMQ_THREAD_NONE")
+    endif()
+endif()
+
+# --- Transport Defaults ---
+if(NOT DEFINED DMQ_TRANSPORT)
+    if(WIN32)
+        set(DMQ_TRANSPORT "DMQ_TRANSPORT_WIN32_UDP")
+    elseif(UNIX AND NOT APPLE)
+        set(DMQ_TRANSPORT "DMQ_TRANSPORT_LINUX_UDP")
+    else()
+        set(DMQ_TRANSPORT "DMQ_TRANSPORT_NONE")
+    endif()
+endif()
+
+# --- Serialization Defaults ---
+if(NOT DEFINED DMQ_SERIALIZE)
+    if(WIN32 OR UNIX)
+        set(DMQ_SERIALIZE "DMQ_SERIALIZE_SERIALIZE")
+    else()
+        set(DMQ_SERIALIZE "DMQ_SERIALIZE_NONE")
+    endif()
+endif()
+
+# --- Utility Class Defaults ---
+if(NOT DEFINED DMQ_UTIL)
+    set(DMQ_UTIL "ON")
+endif()
+
+# --- DataBus Defaults ---
+if(NOT DEFINED DMQ_DATABUS)
+    if(WIN32 OR UNIX)
+        set(DMQ_DATABUS "ON")
+    else()
+        set(DMQ_DATABUS "OFF")
+    endif()
+endif()
+
+# --- DataBus Tools Defaults ---
+if(NOT DEFINED DMQ_DATABUS_TOOLS)
+    if(DMQ_DATABUS STREQUAL "ON" AND (WIN32 OR UNIX))
+        set(DMQ_DATABUS_TOOLS "ON")
+    else()
+        set(DMQ_DATABUS_TOOLS "OFF")
+    endif()
+endif()
+
+# --- Allocator Defaults ---
+if(NOT DEFINED DMQ_ALLOCATOR)
+    set(DMQ_ALLOCATOR "OFF")
+endif()
+
+# --- Assert Defaults ---
+if(NOT DEFINED DMQ_ASSERTS)
+    set(DMQ_ASSERTS "OFF")
+endif()
+
+# --- Logging Defaults ---
+if(NOT DEFINED DMQ_LOG)
+    set(DMQ_LOG "OFF")
+endif()

DelegateMQ/DelegateMQ.cmake

@@ -9,15 +9,9 @@
 #
 # Set DMQ build options:
 #
-#   # Set DMQ build options. Update as necessary.
-#   set(DMQ_ASSERTS "OFF")
-#   set(DMQ_ALLOCATOR "OFF")
-#   set(DMQ_LOG "OFF")
-#   set(DMQ_UTIL "ON")
+#   # Optional: Set DMQ build options to override defaults.
 #   set(DMQ_THREAD "DMQ_THREAD_STDLIB")
-#   set(DMQ_SERIALIZE "DMQ_SERIALIZE_NONE")
-#   set(DMQ_TRANSPORT "DMQ_TRANSPORT_NONE")
-#   include("${CMAKE_SOURCE_DIR}/../../../src/delegate-mq/DelegateMQ.cmake")
+#   include("${CMAKE_SOURCE_DIR}/src/delegate-mq/DelegateMQ.cmake")
 #
 # Use variables to build:
 #
@@ -41,6 +35,9 @@ endmacro()
 set_and_check(DMQ_ROOT_DIR "${CMAKE_CURRENT_LIST_DIR}")
 set_and_check(DMQ_INCLUDE_DIR "${DMQ_ROOT_DIR}")
 
+check("${DMQ_ROOT_DIR}/Defaults.cmake")
+include ("${DMQ_ROOT_DIR}/Defaults.cmake")
+
 check("${DMQ_ROOT_DIR}/Macros.cmake")
 include ("${DMQ_ROOT_DIR}/Macros.cmake")
 

DelegateMQ/External.cmake

@@ -193,18 +193,16 @@ endif()
 # FreeRTOS
 # ---------------------------------------------------------------------------
 if(DMQ_THREAD STREQUAL "DMQ_THREAD_FREERTOS")
-    set_and_check(FREERTOS_ROOT_DIR "${DMQ_ROOT_DIR}/../../../FreeRTOSv202212.00")
+    set_and_check(FREERTOS_ROOT_DIR "${DMQ_ROOT_DIR}/../../../FreeRTOS")
 
     file(GLOB FREERTOS_SOURCES 
-        "${FREERTOS_ROOT_DIR}/FreeRTOS/Source/*.c"
-        "${FREERTOS_ROOT_DIR}/FreeRTOS/Source/include/*.h"
+        "${FREERTOS_ROOT_DIR}/*.c"
+        "${FREERTOS_ROOT_DIR}/include/*.h"
     )
 
-    list(APPEND FREERTOS_SOURCES 
-        "${FREERTOS_ROOT_DIR}/FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace/trcKernelPort.c"
-        "${FREERTOS_ROOT_DIR}/FreeRTOS-Plus/Source/FreeRTOS-Plus-Trace/trcSnapshotRecorder.c"
-        "${FREERTOS_ROOT_DIR}/FreeRTOS/Source/portable/MSVC-MingW/port.c"
-        "${FREERTOS_ROOT_DIR}/FreeRTOS/Source/portable/MemMang/heap_5.c"
+    list(APPEND FREERTOS_SOURCES
+        "${FREERTOS_ROOT_DIR}/portable/MSVC-MingW/port.c"
+        "${FREERTOS_ROOT_DIR}/portable/MemMang/heap_5.c"
     )
 endif()
 

DelegateMQ/delegate/DelegateOpt.h

@@ -4,6 +4,60 @@
 /// @file
 /// @brief Delegate library options header file.
 
+#if defined(_WIN32) || defined(_WIN64)
+    #ifndef WIN32_LEAN_AND_MEAN
+        #define WIN32_LEAN_AND_MEAN
+    #endif
+
+    // If networking is active, include winsock2.h here to prevent macro 
+    // redefinitions when windows.h is included later (e.g. by FreeRTOS or stdlib).
+    #if defined(DMQ_DATABUS) || defined(DMQ_TRANSPORT_ZEROMQ) || \
+        defined(DMQ_TRANSPORT_WIN32_UDP) || defined(DMQ_TRANSPORT_WIN32_TCP) || \
+        defined(DMQ_TRANSPORT_WIN32_PIPE) || defined(DMQ_TRANSPORT_NNG) || \
+        defined(DMQ_TRANSPORT_MQTT)
+        #include <winsock2.h>
+        #include <ws2tcpip.h>
+    #endif
+#endif
+
+// --- PLATFORM AUTO-DETECTION ---
+// If no threading model is defined, attempt to auto-select a default
+#if !defined(DMQ_THREAD_STDLIB) && !defined(DMQ_THREAD_WIN32) && \
+    !defined(DMQ_THREAD_FREERTOS) && !defined(DMQ_THREAD_THREADX) && \
+    !defined(DMQ_THREAD_ZEPHYR) && !defined(DMQ_THREAD_CMSIS_RTOS2) && \
+    !defined(DMQ_THREAD_QT) && !defined(DMQ_THREAD_NONE)
+
+    #if defined(_WIN32) || defined(__linux__) || defined(__APPLE__) || defined(__unix__)
+        #define DMQ_THREAD_STDLIB
+    #endif
+#endif
+
+// If no serialization model is defined, attempt to auto-select a default
+#if !defined(DMQ_SERIALIZE_SERIALIZE) && !defined(DMQ_SERIALIZE_RAPIDJSON) && \
+    !defined(DMQ_SERIALIZE_MSGPACK) && !defined(DMQ_SERIALIZE_CEREAL) && \
+    !defined(DMQ_SERIALIZE_BITSERY) && !defined(DMQ_SERIALIZE_NONE)
+
+    #if defined(_WIN32) || defined(__linux__) || defined(__APPLE__) || defined(__unix__)
+        #define DMQ_SERIALIZE_SERIALIZE
+    #else
+        #define DMQ_SERIALIZE_NONE
+    #endif
+#endif
+
+// Default to DataBus ON on Desktop if not explicitly disabled
+#if !defined(DMQ_DATABUS) && !defined(DMQ_DATABUS_OFF)
+    #if defined(_WIN32) || defined(__linux__) || defined(__APPLE__) || defined(__unix__)
+        #define DMQ_DATABUS
+    #endif
+#endif
+
+// Default to DataBus Tools ON on Desktop if DataBus is active and not explicitly disabled
+#if defined(DMQ_DATABUS) && !defined(DMQ_DATABUS_TOOLS) && !defined(DMQ_DATABUS_TOOLS_OFF)
+    #if defined(_WIN32) || defined(__linux__) || defined(__APPLE__) || defined(__unix__)
+        #define DMQ_DATABUS_TOOLS
+    #endif
+#endif
+
 #include <chrono>
 #if defined(DMQ_THREAD_STDLIB) || defined(DMQ_THREAD_WIN32) || defined(DMQ_THREAD_QT)
     #include <mutex>
@@ -33,6 +87,8 @@
 #elif defined(DMQ_THREAD_CMSIS_RTOS2)
     #include "predef/util/CmsisRtos2Clock.h"
     #include "predef/util/CmsisRtos2Mutex.h"
+#elif defined(DMQ_THREAD_NONE)
+    #include "predef/util/BareMetalClock.h"
 #else
     #include "predef/util/BareMetalClock.h"
 #endif

DelegateMQ/predef/os/cmsis-rtos2/Thread.cpp

@@ -15,6 +15,7 @@ using namespace dmq;
 //----------------------------------------------------------------------------
 Thread::Thread(const std::string& threadName, size_t maxQueueSize) 
     : THREAD_NAME(threadName)
+    , m_exit(false)
 {
     // If 0 is passed, use the default size
     m_queueSize = (maxQueueSize == 0) ? DEFAULT_QUEUE_SIZE : maxQueueSize;
@@ -93,12 +94,14 @@ void Thread::ExitThread()
 {
     if (m_msgq != NULL) 
     {
+        m_exit.store(true);
+
         // Send exit message
         ThreadMsg* msg = new (std::nothrow) ThreadMsg(MSG_EXIT_THREAD);
         if (msg)
         {
-            // Send pointer, wait 100 ticks max
-            if (osMessageQueuePut(m_msgq, &msg, 0, 100) != osOK) 
+            // Send pointer, wait forever to ensure it gets in.
+            if (osMessageQueuePut(m_msgq, &msg, 0, osWaitForever) != osOK) 
             {
                 delete msg; // Failed to send
             }
@@ -112,12 +115,7 @@ void Thread::ExitThread()
         }
 
         // Thread has finished Run(). Now we can safely clean up resources.
-        
-        // Terminate ensures the thread is in INACTIVE state and resources are reclaimed.
-        if (m_thread) {
-             osThreadTerminate(m_thread);
-             m_thread = NULL;
-        }
+        m_thread = NULL;
 
         if (m_msgq) {
              osMessageQueueDelete(m_msgq);
@@ -150,6 +148,17 @@ bool Thread::IsCurrentThread()
     return GetThreadId() == GetCurrentThreadId();
 }
 
+//----------------------------------------------------------------------------
+// GetQueueSize
+//----------------------------------------------------------------------------
+size_t Thread::GetQueueSize()
+{
+    if (m_msgq != NULL) {
+        return (size_t)osMessageQueueGetCount(m_msgq);
+    }
+    return 0;
+}
+
 //----------------------------------------------------------------------------
 // DispatchDelegate
 //----------------------------------------------------------------------------
@@ -192,17 +201,16 @@ void Thread::Run()
 {
     ThreadMsg* msg = nullptr;
 
-    while (true)
+    while (!m_exit.load())
     {
         // Block forever waiting for a message
         // msg is a pointer to ThreadMsg*. The queue holds the pointer.
         if (osMessageQueueGet(m_msgq, &msg, NULL, osWaitForever) == osOK)
         {
             if (!msg) continue;
 
-            switch (msg->GetId())
-            {
-            case MSG_DISPATCH_DELEGATE:
+            int msgId = msg->GetId();
+            if (msgId == MSG_DISPATCH_DELEGATE)
             {
                 auto delegateMsg = msg->GetData();
                 if (delegateMsg) {
@@ -211,24 +219,18 @@ void Thread::Run()
                         invoker->Invoke(delegateMsg);
                     }
                 }
-                break;
-            }
-
-            case MSG_EXIT_THREAD:
-            {
-                delete msg;
-                // Signal ExitThread() that we are done
-                if (m_exitSem) {
-                    osSemaphoreRelease(m_exitSem);
-                }
-                return; 
             }
+            
+            delete msg;
 
-            default:
+            if (msgId == MSG_EXIT_THREAD) {
                 break;
             }
-
-            delete msg;
         }
     }
+
+    // Signal ExitThread() that we are done
+    if (m_exitSem) {
+        osSemaphoreRelease(m_exitSem);
+    }
 }

DelegateMQ/predef/os/cmsis-rtos2/Thread.h

@@ -13,6 +13,13 @@
 /// asynchronous delegates to a dedicated thread on any CMSIS-compliant RTOS 
 /// (e.g., Keil RTX, FreeRTOS wrapped by CMSIS, Zephyr, etc.).
 ///
+/// @note This implementation is a basic port. For reference, the stdlib and win32
+/// implementations provide additional features:
+/// 1. Priority Support: Uses a priority queue to respect dmq::Priority.
+/// 2. Back Pressure: DispatchDelegate() blocks if the queue is full.
+/// 3. Watchdog: Includes a ThreadCheck() heartbeat mechanism.
+/// 4. Synchronized Startup: CreateThread() blocks until the worker thread is ready.
+///
 /// **Key Features:**
 /// * **Task Integration:** Wraps `osThreadNew` to establish a dedicated worker loop.
 /// * **Queue-Based Dispatch:** Uses `osMessageQueue` to receive and process incoming 
@@ -26,6 +33,7 @@
 #include "cmsis_os2.h"
 #include <string>
 #include <memory>
+#include <atomic>
 
 class ThreadMsg;
 
@@ -60,6 +68,9 @@ class Thread : public dmq::IThread
 
     std::string GetThreadName() { return THREAD_NAME; }
 
+    /// Get current queue size
+    size_t GetQueueSize();
+
     virtual void DispatchDelegate(std::shared_ptr<dmq::DelegateMsg> msg) override;
 
 private:
@@ -70,17 +81,17 @@ class Thread : public dmq::IThread
     static void Process(void* argument);
     void Run();
 
+    const std::string THREAD_NAME;
+    size_t m_queueSize;
+    osPriority_t m_priority;
+
     osThreadId_t m_thread = NULL;
     osMessageQueueId_t m_msgq = NULL;
     osSemaphoreId_t m_exitSem = NULL; // Semaphore to signal thread completion
-    
-    const std::string THREAD_NAME;
+    std::atomic<bool> m_exit = false;
 
     // Configurable sizes
     static const uint32_t STACK_SIZE = 2048; // Bytes
-    
-    size_t m_queueSize;
-    osPriority_t m_priority;
 };
 
 #endif // _THREAD_CMSIS_RTOS2_H