Optimised failed test

.gitignore

@@ -1,4 +1,5 @@
 Build/
+Build_Coverage/
 bin/
 *.o
 *.so

CMakeLists.txt

@@ -15,8 +15,16 @@ add_definitions(-DENVIRONMENT=Linux)
 add_definitions(-DMARTe2_TEST_ENVIRONMENT=GTest) # Optional
 add_definitions(-DUSE_PTHREAD)
 
-# Add -pthread flag
+# Add -pthread and coverage flags
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthread")
+if(CMAKE_COMPILER_IS_GNUCXX)
+    option(ENABLE_COVERAGE "Enable coverage reporting" OFF)
+    if(ENABLE_COVERAGE)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} --coverage -fprofile-arcs -ftest-coverage")
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
+        set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --coverage")
+    endif()
+endif()
 
 include_directories(
     ${MARTe2_DIR}/Source/Core/BareMetal/L0Types

Headers/DebugBrokerWrapper.h

@@ -6,6 +6,10 @@
 #include "MemoryMapBroker.h"
 #include "ObjectRegistryDatabase.h"
 #include "ObjectBuilder.h"
+#include "Vector.h"
+#include "FastPollingMutexSem.h"
+#include "HighResolutionTimer.h"
+#include "Atomic.h"
 
 // Original broker headers
 #include "MemoryMapInputBroker.h"
@@ -17,65 +21,69 @@
 #include "MemoryMapMultiBufferOutputBroker.h"
 #include "MemoryMapSynchronisedMultiBufferInputBroker.h"
 #include "MemoryMapSynchronisedMultiBufferOutputBroker.h"
+#include "MemoryMapAsyncOutputBroker.h"
+#include "MemoryMapAsyncTriggerOutputBroker.h"
 
 namespace MARTe {
 
 /**
- * @brief Base implementation for all debug brokers.
+ * @brief Helper for optimized signal processing within brokers.
  */
 class DebugBrokerHelper {
 public:
-    static void Process(BrokerI* broker, DebugService* service, DebugSignalInfo** signalInfoPointers, uint32 numSignals) {
+    static void Process(DebugService* service, BrokerInfo& info) {
         if (service == NULL_PTR(DebugService*)) return;
 
         while (service->IsPaused()) {
             Sleep::MSec(10);
         }
+        
+        if (*info.anyActiveFlag) {
+            uint32 idx = info.currentSetIdx;
+            BrokerActiveSet& set = info.sets[idx];
+            uint64 ts = (uint64)((float64)HighResolutionTimer::Counter() * HighResolutionTimer::Period() * 1000000.0);
 
-        if (signalInfoPointers != NULL_PTR(DebugSignalInfo**)) {
+            for (uint32 i = 0; i < set.numForced; i++) {
-            for (uint32 i = 0; i < numSignals; i++) {
+                SignalExecuteInfo& s = set.forcedSignals[i];
-                DebugSignalInfo *s = signalInfoPointers[i];
+                DebugService::CopySignal(s.memoryAddress, s.forcedValue, s.size);
-                if (s != NULL_PTR(DebugSignalInfo*)) {
+            }
-                    if (s->isTracing || s->isForcing) {
+
-                        uint32 size = broker->GetCopyByteSize(i);
+            for (uint32 i = 0; i < set.numTraced; i++) {
-                        service->ProcessSignal(s, size);
+                SignalExecuteInfo& s = set.tracedSignals[i];
-                    }
+                (void)service->traceBuffer.Push(s.internalID, ts, s.memoryAddress, s.size);
-                }
             }
         }
     }
 
-    static void InitSignals(MemoryMapBroker* broker, DataSourceI &dataSourceIn, DebugService* &service, DebugSignalInfo** &signalInfoPointers, uint32 &numSignals, MemoryMapBrokerCopyTableEntry* copyTable, const char8* functionName, SignalDirection direction) {
+    static void InitSignals(BrokerI* broker, DataSourceI &dataSourceIn, DebugService* &service, DebugSignalInfo** &signalInfoPointers, uint32 numCopies, MemoryMapBrokerCopyTableEntry* copyTable, const char8* functionName, SignalDirection direction, volatile bool* anyActiveFlag) {
-        numSignals = broker->GetNumberOfCopies();
+        if (numCopies > 0) {
-        if (numSignals > 0) {
+            signalInfoPointers = new DebugSignalInfo*[numCopies];
-            signalInfoPointers = new DebugSignalInfo*[numSignals];
+            for (uint32 i=0; i<numCopies; i++) signalInfoPointers[i] = NULL_PTR(DebugSignalInfo*);
-            for (uint32 i=0; i<numSignals; i++) signalInfoPointers[i] = NULL_PTR(DebugSignalInfo*);
         }
 
-        ReferenceContainer *root = ObjectRegistryDatabase::Instance();
+        if (service == NULL_PTR(DebugService*)) service = DebugService::Instance();
-        Reference serviceRef = root->Find("DebugService");
-        if (serviceRef.IsValid()) {
-            service = dynamic_cast<DebugService*>(serviceRef.operator->());
-        }
 
         if (service && (copyTable != NULL_PTR(MemoryMapBrokerCopyTableEntry*))) {
             StreamString dsPath;
             DebugService::GetFullObjectName(dataSourceIn, dsPath);
+            MemoryMapBroker* mmb = dynamic_cast<MemoryMapBroker*>(broker);
 
-            for (uint32 i = 0; i < numSignals; i++) {
+            for (uint32 i = 0; i < numCopies; i++) {
                 void *addr = copyTable[i].dataSourcePointer;
                 TypeDescriptor type = copyTable[i].type;
-                
+                uint32 dsIdx = i;
-                uint32 dsIdx = broker->GetDSCopySignalIndex(i);
+                if (mmb != NULL_PTR(MemoryMapBroker*)) dsIdx = mmb->GetDSCopySignalIndex(i);
+
                 StreamString signalName;
-                if (!dataSourceIn.GetSignalName(dsIdx, signalName)) signalName = "Unknown";
+                if (!dataSourceIn.GetSignalName(dsIdx, signalName)) {
+                    signalName.Printf("Signal_%u", dsIdx);
+                }
                 
-                // 1. Register canonical DataSource name (Absolute, No Root prefix)
+                StreamString dsFullName = dsPath;
-                StreamString dsFullName;
+                if (dsFullName.Size() > 0) dsFullName += ".";
-                dsFullName.Printf("%s.%s", dsPath.Buffer(), signalName.Buffer());
+                dsFullName += signalName;
                 service->RegisterSignal(addr, type, dsFullName.Buffer()); 
 
-                // 2. Also register absolute GAM alias
                 if (functionName != NULL_PTR(const char8*)) {
                     StreamString gamFullName;
                     const char8* dirStr = (direction == InputSignals) ? "In" : "Out";
@@ -83,82 +91,157 @@ public:
                     if (gamRef.IsValid()) {
                         StreamString absGamPath;
                         DebugService::GetFullObjectName(*(gamRef.operator->()), absGamPath);
-                        gamFullName.Printf("%s.%s.%s", absGamPath.Buffer(), dirStr, signalName.Buffer());
+                        gamFullName = absGamPath;
                     } else {
-                        gamFullName.Printf("%s.%s.%s", functionName, dirStr, signalName.Buffer());
+                        gamFullName = functionName;
                     }
+                    gamFullName += ".";
+                    gamFullName += dirStr;
+                    gamFullName += ".";
+                    gamFullName += signalName;
                     signalInfoPointers[i] = service->RegisterSignal(addr, type, gamFullName.Buffer());
                 } else {
                     signalInfoPointers[i] = service->RegisterSignal(addr, type, dsFullName.Buffer());
                 }
             }
+            service->RegisterBroker(signalInfoPointers, numCopies, mmb, anyActiveFlag);
         }
     }
 };
 
-#define DECLARE_DEBUG_BROKER_COMMON(BaseClass) \
+class DebugMemoryMapInputBroker : public MemoryMapInputBroker, public DebugBrokerI {
-    Debug##BaseClass() : BaseClass() { \
+public:
-        service = NULL_PTR(DebugService*); \
+    DebugMemoryMapInputBroker() : MemoryMapInputBroker(), service(NULL), infoPtr(NULL), anyActive(false) {
-        signalInfoPointers = NULL_PTR(DebugSignalInfo**); \
+        (void)ObjectRegistryDatabase::Instance()->Insert(Reference(this));
-        numSignals = 0; \
+    }
-    } \
+    virtual void SetService(DebugService* s) { service = s; }
-    virtual ~Debug##BaseClass() { \
+    virtual bool IsLinked() const { return infoPtr != NULL; }
-        if (signalInfoPointers) delete[] signalInfoPointers; \
+    virtual bool Execute() {
-    } \
+        bool ret = MemoryMapInputBroker::Execute();
-    virtual bool Execute() { \
+        if (ret && infoPtr) DebugBrokerHelper::Process(service, *infoPtr);
-        bool ret = BaseClass::Execute(); \
+        return ret;
-        if (ret) DebugBrokerHelper::Process(this, service, signalInfoPointers, numSignals); \
+    }
-        return ret; \
+    virtual bool Init(SignalDirection direction, DataSourceI &ds, const char8 *const name, void *gamMem) {
-    } \
+        bool ret = MemoryMapInputBroker::Init(direction, ds, name, gamMem);
-private: \
+        if (ret) {
-    DebugService *service; \
+            DebugSignalInfo** sigPtrs = NULL;
-    DebugSignalInfo **signalInfoPointers; \
+            DebugBrokerHelper::InitSignals(this, ds, service, sigPtrs, GetNumberOfCopies(), this->copyTable, name, direction, &anyActive);
-    uint32 numSignals;
+            if (service) infoPtr = service->GetBrokerInfo(service->numberOfBrokers - 1);
-
+        }
-#define DECLARE_DEBUG_BROKER(BaseClass) \
+        return ret;
-class Debug##BaseClass : public BaseClass { \
+    }
-public: \
+    DebugService* service;
-    DECLARE_DEBUG_BROKER_COMMON(BaseClass) \
+    BrokerInfo* infoPtr;
-    virtual bool Init(SignalDirection direction, DataSourceI &ds, const char8 *const name, void *gamMem) { \
+    volatile bool anyActive;
-        bool ret = BaseClass::Init(direction, ds, name, gamMem); \
-        if (ret) DebugBrokerHelper::InitSignals(this, ds, service, signalInfoPointers, numSignals, this->copyTable, name, direction); \
-        return ret; \
-    } \
-    virtual bool Init(SignalDirection direction, DataSourceI &ds, const char8 *const name, void *gamMem, const bool optim) { \
-        bool ret = BaseClass::Init(direction, ds, name, gamMem, optim); \
-        if (ret) DebugBrokerHelper::InitSignals(this, ds, service, signalInfoPointers, numSignals, this->copyTable, name, direction); \
-        return ret; \
-    } \
-}; \
-class Debug##BaseClass##Builder : public ObjectBuilder { \
-public: \
-    virtual Object *Build(HeapI* const heap) const { return new (heap) Debug##BaseClass(); } \
 };
 
-#define DECLARE_DEBUG_BROKER_NO_OPTIM(BaseClass) \
+template <typename T>
-class Debug##BaseClass : public BaseClass { \
+class DebugGenericBroker : public T, public DebugBrokerI {
-public: \
+public:
-    DECLARE_DEBUG_BROKER_COMMON(BaseClass) \
+    DebugGenericBroker() : T(), service(NULL), infoPtr(NULL), anyActive(false) {
-    virtual bool Init(SignalDirection direction, DataSourceI &ds, const char8 *const name, void *gamMem) { \
+        (void)ObjectRegistryDatabase::Instance()->Insert(Reference(this));
-        bool ret = BaseClass::Init(direction, ds, name, gamMem); \
+    }
-        if (ret) DebugBrokerHelper::InitSignals(this, ds, service, signalInfoPointers, numSignals, this->copyTable, name, direction); \
+    virtual void SetService(DebugService* s) { service = s; }
-        return ret; \
+    virtual bool IsLinked() const { return infoPtr != NULL; }
-    } \
+    virtual bool Execute() {
-}; \
+        bool ret = T::Execute();
-class Debug##BaseClass##Builder : public ObjectBuilder { \
+        if (ret && infoPtr) DebugBrokerHelper::Process(service, *infoPtr);
-public: \
+        return ret;
-    virtual Object *Build(HeapI* const heap) const { return new (heap) Debug##BaseClass(); } \
+    }
+    virtual bool Init(SignalDirection direction, DataSourceI &ds, const char8 *const name, void *gamMem) {
+        bool ret = T::Init(direction, ds, name, gamMem);
+        if (ret) {
+            DebugSignalInfo** sigPtrs = NULL;
+            DebugBrokerHelper::InitSignals(this, ds, service, sigPtrs, this->GetNumberOfCopies(), this->copyTable, name, direction, &anyActive);
+            if (service) infoPtr = service->GetBrokerInfo(service->numberOfBrokers - 1);
+        }
+        return ret;
+    }
+    DebugService* service;
+    BrokerInfo* infoPtr;
+    volatile bool anyActive;
 };
 
-DECLARE_DEBUG_BROKER(MemoryMapInputBroker)
+class DebugMemoryMapAsyncOutputBroker : public MemoryMapAsyncOutputBroker, public DebugBrokerI {
-DECLARE_DEBUG_BROKER(MemoryMapOutputBroker)
+public:
-DECLARE_DEBUG_BROKER(MemoryMapSynchronisedInputBroker)
+    DebugMemoryMapAsyncOutputBroker() : MemoryMapAsyncOutputBroker(), service(NULL), infoPtr(NULL), anyActive(false) {
-DECLARE_DEBUG_BROKER(MemoryMapSynchronisedOutputBroker)
+        (void)ObjectRegistryDatabase::Instance()->Insert(Reference(this));
-DECLARE_DEBUG_BROKER_NO_OPTIM(MemoryMapInterpolatedInputBroker)
+    }
-DECLARE_DEBUG_BROKER(MemoryMapMultiBufferInputBroker)
+    virtual void SetService(DebugService* s) { service = s; }
-DECLARE_DEBUG_BROKER(MemoryMapMultiBufferOutputBroker)
+    virtual bool IsLinked() const { return infoPtr != NULL; }
-DECLARE_DEBUG_BROKER(MemoryMapSynchronisedMultiBufferInputBroker)
+    virtual bool Execute() {
-DECLARE_DEBUG_BROKER(MemoryMapSynchronisedMultiBufferOutputBroker)
+        bool ret = MemoryMapAsyncOutputBroker::Execute();
+        if (ret && infoPtr) DebugBrokerHelper::Process(service, *infoPtr);
+        return ret;
+    }
+    virtual bool InitWithBufferParameters(const SignalDirection d, DataSourceI &ds, const char8* n, void* m, const uint32 nb, const ProcessorType& c, const uint32 s) {
+        bool ret = MemoryMapAsyncOutputBroker::InitWithBufferParameters(d, ds, n, m, nb, c, s);
+        if (ret) {
+            DebugSignalInfo** sigPtrs = NULL;
+            DebugBrokerHelper::InitSignals(this, ds, service, sigPtrs, this->GetNumberOfCopies(), this->copyTable, n, d, &anyActive);
+            if (service) infoPtr = service->GetBrokerInfo(service->numberOfBrokers - 1);
+        }
+        return ret;
+    }
+    DebugService* service;
+    BrokerInfo* infoPtr;
+    volatile bool anyActive;
+};
+
+class DebugMemoryMapAsyncTriggerOutputBroker : public MemoryMapAsyncTriggerOutputBroker, public DebugBrokerI {
+public:
+    DebugMemoryMapAsyncTriggerOutputBroker() : MemoryMapAsyncTriggerOutputBroker(), service(NULL), infoPtr(NULL), anyActive(false) {
+        (void)ObjectRegistryDatabase::Instance()->Insert(Reference(this));
+    }
+    virtual void SetService(DebugService* s) { service = s; }
+    virtual bool IsLinked() const { return infoPtr != NULL; }
+    virtual bool Execute() {
+        bool ret = MemoryMapAsyncTriggerOutputBroker::Execute();
+        if (ret && infoPtr) DebugBrokerHelper::Process(service, *infoPtr);
+        return ret;
+    }
+    virtual bool InitWithTriggerParameters(const SignalDirection d, DataSourceI &ds, const char8* n, void* m, const uint32 nb, const uint32 pre, const uint32 post, const ProcessorType& c, const uint32 s) {
+        bool ret = MemoryMapAsyncTriggerOutputBroker::InitWithTriggerParameters(d, ds, n, m, nb, pre, post, c, s);
+        if (ret) {
+            DebugSignalInfo** sigPtrs = NULL;
+            DebugBrokerHelper::InitSignals(this, ds, service, sigPtrs, this->GetNumberOfCopies(), this->copyTable, n, d, &anyActive);
+            if (service) infoPtr = service->GetBrokerInfo(service->numberOfBrokers - 1);
+        }
+        return ret;
+    }
+    DebugService* service;
+    BrokerInfo* infoPtr;
+    volatile bool anyActive;
+};
+
+typedef DebugGenericBroker<MemoryMapOutputBroker> DebugMemoryMapOutputBroker;
+typedef DebugGenericBroker<MemoryMapSynchronisedInputBroker> DebugMemoryMapSynchronisedInputBroker;
+typedef DebugGenericBroker<MemoryMapSynchronisedOutputBroker> DebugMemoryMapSynchronisedOutputBroker;
+typedef DebugGenericBroker<MemoryMapInterpolatedInputBroker> DebugMemoryMapInterpolatedInputBroker;
+typedef DebugGenericBroker<MemoryMapMultiBufferInputBroker> DebugMemoryMapMultiBufferInputBroker;
+typedef DebugGenericBroker<MemoryMapMultiBufferOutputBroker> DebugMemoryMapMultiBufferOutputBroker;
+typedef DebugGenericBroker<MemoryMapSynchronisedMultiBufferInputBroker> DebugMemoryMapSynchronisedMultiBufferInputBroker;
+typedef DebugGenericBroker<MemoryMapSynchronisedMultiBufferOutputBroker> DebugMemoryMapSynchronisedMultiBufferOutputBroker;
+
+template <typename T>
+class DebugBrokerBuilder : public ObjectBuilder {
+public:
+    virtual Object *Build(HeapI* const heap) const { 
+        return new (heap) T(); 
+    }
+};
+
+typedef DebugBrokerBuilder<DebugMemoryMapInputBroker> DebugMemoryMapInputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapOutputBroker> DebugMemoryMapOutputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapSynchronisedInputBroker> DebugMemoryMapSynchronisedInputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapSynchronisedOutputBroker> DebugMemoryMapSynchronisedOutputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapInterpolatedInputBroker> DebugMemoryMapInterpolatedInputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapMultiBufferInputBroker> DebugMemoryMapMultiBufferInputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapMultiBufferOutputBroker> DebugMemoryMapMultiBufferOutputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapSynchronisedMultiBufferInputBroker> DebugMemoryMapSynchronisedMultiBufferInputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapSynchronisedMultiBufferOutputBroker> DebugMemoryMapSynchronisedMultiBufferOutputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapAsyncOutputBroker> DebugMemoryMapAsyncOutputBrokerBuilder;
+typedef DebugBrokerBuilder<DebugMemoryMapAsyncTriggerOutputBroker> DebugMemoryMapAsyncTriggerOutputBrokerBuilder;
 
 }
 

Headers/DebugCore.h

@@ -4,6 +4,7 @@
 #include "CompilerTypes.h"
 #include "TypeDescriptor.h"
 #include "StreamString.h"
+#include <cstring> 
 
 namespace MARTe {
 
@@ -28,6 +29,10 @@ struct TraceHeader {
 };
 #pragma pack(pop)
 
+/**
+ * @brief Ring buffer for high-frequency signal tracing.
+ * @details New format per sample: [ID:4][Timestamp:8][Size:4][Data:N]
+ */
 class TraceRingBuffer {
 public:
     TraceRingBuffer() {
@@ -54,43 +59,53 @@ public:
         return (buffer != NULL_PTR(uint8*));
     }
 
-    bool Push(uint32 signalID, void* data, uint32 size) {
+    bool Push(uint32 signalID, uint64 timestamp, void* data, uint32 size) {
-        uint32 packetSize = 4 + 4 + size;
+        uint32 packetSize = 4 + 8 + 4 + size; // ID + TS + Size + Data
         uint32 read = readIndex; 
         uint32 write = writeIndex;
-        uint32 available = (read <= write) ? (bufferSize - (write - read) - 1) : (read - write - 1);
+        
+        uint32 available = 0;
+        if (read <= write) {
+            available = bufferSize - (write - read) - 1;
+        } else {
+            available = read - write - 1;
+        }
 
         if (available < packetSize) return false;
 
-        // Use temporary write index to ensure atomic update
         uint32 tempWrite = write;
         WriteToBuffer(&tempWrite, &signalID, 4);
+        WriteToBuffer(&tempWrite, &timestamp, 8);
         WriteToBuffer(&tempWrite, &size, 4);
         WriteToBuffer(&tempWrite, data, size);
         
-        // Final atomic update
         writeIndex = tempWrite;
         return true;
     }
 
-    bool Pop(uint32 &signalID, void* dataBuffer, uint32 &size, uint32 maxSize) {
+    bool Pop(uint32 &signalID, uint64 &timestamp, void* dataBuffer, uint32 &size, uint32 maxSize) {
         uint32 read = readIndex;
         uint32 write = writeIndex;
         if (read == write) return false;
 
         uint32 tempRead = read;
-        uint32 tempId, tempSize;
+        uint32 tempId = 0;
+        uint64 tempTs = 0;
+        uint32 tempSize = 0;
+        
         ReadFromBuffer(&tempRead, &tempId, 4);
+        ReadFromBuffer(&tempRead, &tempTs, 8);
         ReadFromBuffer(&tempRead, &tempSize, 4);
         
         if (tempSize > maxSize) {
-            // Error case: drop data up to writeIndex
             readIndex = write;
             return false;
         }
 
         ReadFromBuffer(&tempRead, dataBuffer, tempSize);
+        
         signalID = tempId;
+        timestamp = tempTs;
         size = tempSize;
         
         readIndex = tempRead;
@@ -106,18 +121,30 @@ public:
 
 private:
     void WriteToBuffer(uint32 *idx, void* src, uint32 count) {
-        uint8* s = (uint8*)src;
+        uint32 current = *idx;
-        for (uint32 i=0; i<count; i++) {
+        uint32 spaceToEnd = bufferSize - current;
-            buffer[*idx] = s[i];
+        if (count <= spaceToEnd) {
-            *idx = (*idx + 1) % bufferSize;
+            std::memcpy(&buffer[current], src, count);
+            *idx = (current + count) % bufferSize;
+        } else {
+            std::memcpy(&buffer[current], src, spaceToEnd);
+            uint32 remaining = count - spaceToEnd;
+            std::memcpy(&buffer[0], (uint8*)src + spaceToEnd, remaining);
+            *idx = remaining;
         }
     }
 
     void ReadFromBuffer(uint32 *idx, void* dst, uint32 count) {
-        uint8* d = (uint8*)dst;
+        uint32 current = *idx;
-        for (uint32 i=0; i<count; i++) {
+        uint32 spaceToEnd = bufferSize - current;
-            d[i] = buffer[*idx];
+        if (count <= spaceToEnd) {
-            *idx = (*idx + 1) % bufferSize;
+            std::memcpy(dst, &buffer[current], count);
+            *idx = (current + count) % bufferSize;
+        } else {
+            std::memcpy(dst, &buffer[current], spaceToEnd);
+            uint32 remaining = count - spaceToEnd;
+            std::memcpy((uint8*)dst + spaceToEnd, &buffer[0], remaining);
+            *idx = remaining;
         }
     }
 

Headers/DebugService.h

@@ -13,6 +13,42 @@
 
 namespace MARTe {
 
+class MemoryMapBroker;
+class DebugService;
+
+/**
+ * @brief Interface for instrumented brokers to allow service adoption.
+ */
+class DebugBrokerI {
+public:
+    virtual ~DebugBrokerI() {}
+    virtual void SetService(DebugService* service) = 0;
+    virtual bool IsLinked() const = 0;
+};
+
+struct SignalExecuteInfo {
+    void* memoryAddress;
+    void* forcedValue; 
+    uint32 internalID;
+    uint32 size;
+};
+
+struct BrokerActiveSet {
+    SignalExecuteInfo* forcedSignals;
+    uint32 numForced;
+    SignalExecuteInfo* tracedSignals;
+    uint32 numTraced;
+};
+
+struct BrokerInfo {
+    DebugSignalInfo** signalPointers;
+    uint32 numSignals;
+    MemoryMapBroker* broker;
+    BrokerActiveSet sets[2];
+    volatile uint32 currentSetIdx; 
+    volatile bool* anyActiveFlag;
+};
+
 struct SignalAlias {
     StreamString name;
     uint32 signalIndex;
@@ -20,6 +56,7 @@ struct SignalAlias {
 
 class DebugService : public ReferenceContainer, public MessageI, public EmbeddedServiceMethodBinderI {
 public:
+    friend class DebugServiceTest;
     CLASS_REGISTER_DECLARATION()
 
     DebugService();
@@ -28,10 +65,23 @@ public:
     virtual bool Initialise(StructuredDataI & data);
 
     DebugSignalInfo* RegisterSignal(void* memoryAddress, TypeDescriptor type, const char8* name);
-    void ProcessSignal(DebugSignalInfo* signalInfo, uint32 size);
+    
+    static inline void CopySignal(void* dst, const void* src, const uint32 size) {
+        if (size == 4u) *static_cast<uint32*>(dst) = *static_cast<const uint32*>(src);
+        else if (size == 8u) *static_cast<uint64*>(dst) = *static_cast<const uint64*>(src);
+        else if (size == 1u) *static_cast<uint8*>(dst) = *static_cast<const uint8*>(src);
+        else if (size == 2u) *static_cast<uint16*>(dst) = *static_cast<const uint16*>(src);
+        else MemoryOperationsHelper::Copy(dst, src, size);
+    }
+
+    void ProcessSignal(DebugSignalInfo* signalInfo, uint32 size, uint64 timestamp);
+
+    void RegisterBroker(DebugSignalInfo** signalPointers, uint32 numSignals, MemoryMapBroker* broker, volatile bool* anyActiveFlag);
 
     virtual ErrorManagement::ErrorType Execute(ExecutionInfo & info);
 
+    static DebugService* Instance();
+
     bool IsPaused() const { return isPaused; }
     void SetPaused(bool paused) { isPaused = paused; }
 
@@ -44,9 +94,29 @@ public:
     void ListNodes(const char8* path, BasicTCPSocket *client);
     void InfoNode(const char8* path, BasicTCPSocket *client);
 
+    void UpdateBrokersActiveStatus();
+
+    BrokerInfo* GetBrokerInfo(uint32 index) {
+        if (index < numberOfBrokers) return &brokers[index];
+        return NULL_PTR(BrokerInfo*);
+    }
+
+    // PERFORMANCE-CRITICAL MEMBERS
+    static const uint32 MAX_BROKERS = 256;
+    BrokerInfo brokers[MAX_BROKERS];
+    uint32 numberOfBrokers;
+    TraceRingBuffer traceBuffer;
+
+    static const uint32 MAX_SIGNALS = 512;
+    DebugSignalInfo signals[MAX_SIGNALS];
+    uint32 numberOfSignals;
+
+    static const uint32 MAX_ALIASES = 1024;
+    SignalAlias aliases[MAX_ALIASES];
+    uint32 numberOfAliases;
+
 private:
     void HandleCommand(StreamString cmd, BasicTCPSocket *client);
-    
     uint32 ExportTree(ReferenceContainer *container, StreamString &json);
     void PatchRegistry();
     
@@ -85,24 +155,15 @@ private:
     ThreadIdentifier serverThreadId;
     ThreadIdentifier streamerThreadId;
 
-    static const uint32 MAX_SIGNALS = 4096;
-    DebugSignalInfo signals[MAX_SIGNALS];
-    uint32 numberOfSignals;
-
-    static const uint32 MAX_ALIASES = 8192;
-    SignalAlias aliases[MAX_ALIASES];
-    uint32 numberOfAliases;
-
     FastPollingMutexSem mutex;
-    TraceRingBuffer traceBuffer;
 
     static const uint32 MAX_CLIENTS = 16;
     BasicTCPSocket* activeClients[MAX_CLIENTS];
     FastPollingMutexSem clientsMutex;
-
-    static DebugService* instance;
 };
 
+extern DebugService* GlobalDebugServiceInstance;
+
 }
 
 #endif

SPECS.md

@@ -9,8 +9,33 @@ Implement a "Zero-Code-Change" observability layer for the MARTe2 real-time fram
 - **FR-02 (Telemetry):** Stream high-frequency signal data (verified up to 100Hz) to a remote client.
 - **FR-03 (Forcing):** Allow manual override of signal values in memory during execution.
 - **FR-04 (Logs):** Stream global framework logs to a dedicated terminal via a standalone `TcpLogger` service.
-- **FR-05 (Execution Control):** Pause and resume the real-time execution threads via scheduler injection.
+- **FR-05 (Log Filtering):** The client must support filtering logs by type (Debug, Information, Warning, FatalError) and by content using regular expressions.
-- **FR-06 (UI):** Provide a native, immediate-mode GUI for visualization (Oscilloscope).
+- **FR-06 (Execution & UI):** 
+    - Provide a native GUI for visualization.
+    - Support Pause/Resume of real-time execution threads via scheduler injection.
+- **FR-07 (Session Management):** 
+    - The top panel must provide a "Disconnect" button to close active network streams.
+    - Support runtime re-configuration and "Apply & Reconnect" logic.
+- **FR-08 (Decoupled Tracing):** 
+ Clicking `trace` activates telemetry; data is buffered and shown as a "Last Value" in the sidebar, but not plotted until manually assigned.
+- **FR-08 (Advanced Plotting):** 
+    - Support multiple plot panels with perfectly synchronized time (X) axes.
+    - Drag-and-drop signals from the traced list into specific plots.
+    - Automatic distinct color assignment for each signal added to a plot.
+    - Plot modes: Standard (Time Series) and Logic Analyzer (Stacked rows).
+    - Signal transformations: Gain, offset, units, and custom labels.
+    - Visual styling: Deep customization of colors, line styles (Solid, Dashed, etc.), and marker shapes (Circle, Square, etc.).
+- **FR-09 (Navigation):** 
+    - Context menus for resetting zoom (X, Y, or both).
+    - "Fit to View" functionality that automatically scales both axes to encompass all available buffered data points.
+- **FR-10 (Scope Mode):**
+    - High-performance oscilloscope mode with configurable time windows (10ms to 10s).
+    - Global synchronization of time axes across all plot panels.
+    - Support for Free-run and Triggered acquisition (Single/Continuous, rising/falling edges).
+- **FR-11 (Data Recording):**
+    - Record any traced signal to disk in Parquet format.
+    - Native file dialog for destination selection.
+    - Visual recording indicator in the GUI.
 
 ### 2.2 Technical Constraints (TC)
 - **TC-01:** No modifications allowed to the MARTe2 core library or component source code.
@@ -22,3 +47,4 @@ Implement a "Zero-Code-Change" observability layer for the MARTe2 real-time fram
 - **Latency:** Telemetry dispatch overhead < 5 microseconds per signal.
 - **Throughput:** Support for 100Hz+ sampling rates with zero packet loss on local networks.
 - **Scalability:** Handle up to 4096 unique signals and 16 simultaneous client connections.
+- **Code Quality:** Maintain a minimum of **85% code coverage** across all core service and broker logic.

Test/Configurations/debug_test.cfg

@@ -1,3 +1,19 @@
++DebugService = {
+    Class = DebugService
+    ControlPort = 8080
+    UdpPort = 8081
+    StreamIP = "127.0.0.1"
+}
+
++LoggerService = {
+    Class = LoggerService
+    CPUs = 0x1
+    +DebugConsumer = {
+        Class = TcpLogger
+        Port = 8082
+    }
+}
+
 +App = {
     Class = RealTimeApplication
     +Functions = {
@@ -8,7 +24,7 @@
                 Counter = {
                     DataSource = Timer
                     Type = uint32
-                    Frequency = 100
+                    Frequency = 1000
                 }
                 Time = {
                     DataSource = Timer
@@ -21,11 +37,33 @@
                     Type = uint32
                 }
                 Time = {
-                    DataSource = Logger
+                    DataSource = DDB
                     Type = uint32
                 }
             }
         }
+        +GAM2 = {
+            Class = IOGAM
+            InputSignals = {
+                Counter = {
+                    DataSource = TimerSlow
+                    Frequency = 10
+                }
+                Time = {
+                    DataSource = TimerSlow
+                }
+            }
+            OutputSignals = {
+                Counter = {
+                    Type = uint32
+                    DataSource = Logger
+                }
+                Time = {
+                    Type = uint32
+                    DataSource = Logger
+                }
+            }
+        }
     }
     +Data = {
         Class = ReferenceContainer
@@ -41,6 +79,17 @@
                 }
             }
         }
+        +TimerSlow = {
+            Class = LinuxTimer
+            Signals = {
+                Counter = {
+                    Type = uint32
+                }
+                Time = {
+                    Type = uint32
+                }
+            }
+        }
         +Logger = {
             Class = LoggerDataSource
             Signals = {
@@ -75,6 +124,10 @@
                     Class = RealTimeThread
                     Functions = {GAM1}
                 }
+                +Thread2 = {
+                    Class = RealTimeThread
+                    Functions = {GAM2}
+                }
             }
         }
     }
@@ -83,19 +136,3 @@
         TimingDataSource = DAMS
     }
 }
-
-+DebugService = {
-    Class = DebugService
-    ControlPort = 8080
-    UdpPort = 8081
-    StreamIP = "127.0.0.1"
-}
-
-+LoggerService = {
-    Class = LoggerService
-    CPUs = 0x1
-    +DebugConsumer = {
-        Class = TcpLogger
-        Port = 8082
-    }
-}

Test/Integration/BrokerExecuteTest.cpp

@@ -0,0 +1,109 @@
+#include "DebugService.h"
+#include "DebugBrokerWrapper.h"
+#include "MemoryMapInputBroker.h"
+#include "ObjectRegistryDatabase.h"
+#include "StandardParser.h"
+#include <stdio.h>
+#include <assert.h>
+
+using namespace MARTe;
+
+namespace MARTe {
+
+class ManualDebugMemoryMapInputBroker : public DebugMemoryMapInputBroker {
+public:
+    virtual bool Execute() {
+        if (infoPtr) DebugBrokerHelper::Process(service, *infoPtr);
+        return true;
+    }
+    using MemoryMapBroker::copyTable;
+};
+
+class MockDS : public DataSourceI {
+public:
+    CLASS_REGISTER_DECLARATION()
+    MockDS() { SetName("MockDS"); }
+    virtual bool AllocateMemory() { return true; }
+    virtual uint32 GetNumberOfMemoryBuffers() { return 1; }
+    virtual bool GetSignalMemoryBuffer(const uint32 signalIdx, const uint32 bufferIdx, void *&signalAddress) { 
+        static uint32 val = 0;
+        signalAddress = &val;
+        return true; 
+    }
+    virtual const char8 *GetBrokerName(StructuredDataI &data, const SignalDirection direction) { return "MemoryMapInputBroker"; }
+    virtual bool GetInputBrokers(ReferenceContainer &inputBrokers, const char8 *const functionName, void *const gamMem) { return true; }
+    virtual bool GetOutputBrokers(ReferenceContainer &outputBrokers, const char8 *const functionName, void *const gamMem) { return true; }
+    virtual bool PrepareNextState(const char8 *const currentStateName, const char8 *const nextStateName) { return true; }
+    virtual bool Synchronise() { return true; }
+};
+CLASS_REGISTER(MockDS, "1.0")
+
+void RunTest() {
+    printf("--- Broker Execute Path Test (Isolated) ---\n");
+
+    DebugService* service = new DebugService();
+    service->traceBuffer.Init(1024 * 1024);
+    ConfigurationDatabase cfg;
+    cfg.Write("ControlPort", (uint32)0);
+    cfg.Write("StreamPort", (uint32)0);
+    assert(service->Initialise(cfg));
+
+    ObjectRegistryDatabase::Instance()->Insert(Reference(service));
+
+    MockDS ds;
+    uint32 gamMem = 42;
+
+    ManualDebugMemoryMapInputBroker* broker = new ManualDebugMemoryMapInputBroker();
+    broker->service = service;
+
+    printf("Manually bootstrapping Broker for testing...\n");
+    broker->copyTable = new MemoryMapBrokerCopyTableEntry[1];
+    broker->copyTable[0].copySize = 4;
+    broker->copyTable[0].dataSourcePointer = &gamMem; 
+    broker->copyTable[0].gamPointer = &gamMem;
+    broker->copyTable[0].type = UnsignedInteger32Bit;
+    
+    DebugSignalInfo** sigPtrs = NULL;
+    DebugBrokerHelper::InitSignals(NULL_PTR(BrokerI*), ds, service, sigPtrs, 1, broker->copyTable, "TestGAM", InputSignals, &broker->anyActive);
+    broker->infoPtr = &service->brokers[service->numberOfBrokers - 1];
+
+    printf("Broker ready. Registered signals in service: %u\n", service->numberOfSignals);
+
+    printf("Executing IDLE cycle...\n");
+    broker->Execute();
+    assert(service->traceBuffer.Count() == 0);
+
+    printf("Manually enabling TRACE for first signal...\n");
+    // Directly enable tracing on the signal info to bypass name matching
+    service->signals[0].isTracing = true;
+    service->signals[0].decimationFactor = 1;
+    service->signals[0].decimationCounter = 0;
+    
+    printf("Updating brokers active status...\n");
+    service->UpdateBrokersActiveStatus();
+    assert(broker->anyActive == true);
+
+    printf("Executing TRACE cycle...\n");
+    broker->Execute();
+    
+    uint32 rbCount = service->traceBuffer.Count();
+    printf("Trace Buffer Count: %u\n", rbCount);
+    
+    if (rbCount > 0) {
+        printf("SUCCESS: Data reached Trace Buffer via Broker!\n");
+        uint32 rid, rsize; uint64 rts; uint32 rval;
+        assert(service->traceBuffer.Pop(rid, rts, &rval, rsize, 4));
+        printf("Value popped: %u (ID=%u, TS=%lu)\n", rval, rid, rts);
+        assert(rval == 42);
+    } else {
+        printf("FAILURE: Trace Buffer is still empty.\n");
+    }
+
+    ObjectRegistryDatabase::Instance()->Purge();
+}
+}
+
+int main() {
+    MARTe::RunTest();
+    return 0;
+}

Test/Integration/CMakeLists.txt

@@ -9,3 +9,12 @@ target_link_libraries(ValidationTest marte_dev ${MARTe2_LIB} ${IOGAM_LIB} ${Linu
 
 add_executable(SchedulerTest SchedulerTest.cpp)
 target_link_libraries(SchedulerTest marte_dev ${MARTe2_LIB} ${IOGAM_LIB} ${LinuxTimer_LIB})
+
+add_executable(PerformanceTest PerformanceTest.cpp)
+target_link_libraries(PerformanceTest marte_dev ${MARTe2_LIB})
+
+add_executable(BrokerExecuteTest BrokerExecuteTest.cpp)
+target_link_libraries(BrokerExecuteTest marte_dev ${MARTe2_LIB})
+
+add_executable(FinalValidationTest FinalValidationTest.cpp)
+target_link_libraries(FinalValidationTest marte_dev ${MARTe2_LIB} ${IOGAM_LIB} ${LinuxTimer_LIB} ${LoggerDataSource_LIB})

Test/Integration/FinalValidationTest.cpp

@@ -0,0 +1,217 @@
+#include "DebugService.h"
+#include "DebugCore.h"
+#include "ObjectRegistryDatabase.h"
+#include "StandardParser.h"
+#include "RealTimeApplication.h"
+#include "GlobalObjectsDatabase.h"
+#include "BasicUDPSocket.h"
+#include "BasicTCPSocket.h"
+#include "HighResolutionTimer.h"
+#include <stdio.h>
+#include <assert.h>
+
+using namespace MARTe;
+
+void RunFinalValidation() {
+    printf("--- MARTe2 Debug Final Validation (End-to-End) ---\n");
+
+    ObjectRegistryDatabase::Instance()->Purge();
+
+    // 1. Initialise DebugService FIRST
+    const char8 * const service_cfg = 
+    "+DebugService = {"
+    "    Class = DebugService "
+    "    ControlPort = 8080 "
+    "    UdpPort = 8081 "
+    "    StreamIP = \"127.0.0.1\" "
+    "}";
+
+    StreamString ssSrv = service_cfg;
+    ssSrv.Seek(0);
+    ConfigurationDatabase cdbSrv;
+    StandardParser parserSrv(ssSrv, cdbSrv);
+    assert(parserSrv.Parse());
+    
+    cdbSrv.MoveToRoot();
+    if (cdbSrv.MoveRelative("+DebugService")) {
+        ConfigurationDatabase child;
+        cdbSrv.Copy(child);
+        cdbSrv.MoveToAncestor(1u);
+        Reference ref("DebugService", GlobalObjectsDatabase::Instance()->GetStandardHeap());
+        ref->SetName("DebugService");
+        if (!ref->Initialise(child)) {
+            printf("ERROR: Failed to initialise DebugService\n");
+            return;
+        }
+        ObjectRegistryDatabase::Instance()->Insert(ref);
+        printf("[Init] DebugService started.\n");
+    }
+
+    // 2. Minimal App configuration
+    const char8 * const minimal_app_cfg = 
+    "+App = {"
+    "    Class = RealTimeApplication "
+    "    +Functions = {"
+    "        Class = ReferenceContainer "
+    "        +GAM1 = {"
+    "            Class = IOGAM "
+    "            InputSignals = {"
+    "                Counter = { DataSource = Timer Type = uint32 Frequency = 1000 }"
+    "            }"
+    "            OutputSignals = {"
+    "                Counter = { DataSource = DDB Type = uint32 }"
+    "            }"
+    "        }"
+    "    }"
+    "    +Data = {"
+    "        Class = ReferenceContainer "
+    "        DefaultDataSource = DDB "
+    "        +Timer = { Class = LinuxTimer SleepTime = 1000 Signals = { +Counter = { Type = uint32 } } }"
+    "        +DDB = { Class = GAMDataSource Signals = { +Counter = { Type = uint32 } } }"
+    "        +DAMS = { Class = TimingDataSource }"
+    "    }"
+    "    +States = {"
+    "        Class = ReferenceContainer "
+    "        +State1 = { Class = RealTimeState +Threads = { Class = ReferenceContainer +Thread1 = { Class = RealTimeThread Functions = {GAM1} } } }"
+    "    }"
+    "    +Scheduler = { Class = GAMScheduler TimingDataSource = DAMS }"
+    "}";
+
+    StreamString ssApp = minimal_app_cfg;
+    ssApp.Seek(0);
+    ConfigurationDatabase cdbApp;
+    StandardParser parserApp(ssApp, cdbApp);
+    assert(parserApp.Parse());
+    
+    cdbApp.MoveToRoot();
+    if (cdbApp.MoveRelative("+App")) {
+        ConfigurationDatabase child;
+        cdbApp.Copy(child);
+        cdbApp.MoveToAncestor(1u);
+        Reference ref("RealTimeApplication", GlobalObjectsDatabase::Instance()->GetStandardHeap());
+        ref->SetName("App");
+        if (ref->Initialise(child)) {
+            ObjectRegistryDatabase::Instance()->Insert(ref);
+            printf("[Init] App object created.\n");
+        } else {
+            printf("ERROR: Failed to initialise App object.\n");
+            return;
+        }
+    }
+
+    Reference appRef = ObjectRegistryDatabase::Instance()->Find("App");
+    RealTimeApplication* app = dynamic_cast<RealTimeApplication*>(appRef.operator->());
+
+    // 3. Start Application
+    printf("Configuring Application...\n");
+    if (!app->ConfigureApplication()) {
+        printf("ERROR: ConfigureApplication failed.\n");
+        return;
+    }
+    printf("Preparing State1...\n");
+    if (app->PrepareNextState("State1") != ErrorManagement::NoError) {
+        printf("ERROR: Failed to prepare State1.\n");
+        return;
+    }
+    printf("Starting State1 Execution...\n");
+    if (app->StartNextStateExecution() != ErrorManagement::NoError) {
+        printf("ERROR: Failed to start State1 execution.\n");
+        return;
+    }
+
+    printf("Application running. Starting client simulation...\n");
+    Sleep::MSec(1000);
+
+    // 4. Act as Client: Send Commands
+    BasicTCPSocket client;
+    if (client.Connect("127.0.0.1", 8080, TimeoutType(2000))) {
+        printf("[Client] Connected to DebugService.\n");
+        
+        // Command 1: TREE
+        printf("[Client] Sending TREE...\n");
+        uint32 cmdLen = 5;
+        client.Write("TREE\n", cmdLen);
+        char buf[4096]; uint32 rsize = 4096;
+        if (client.Read(buf, rsize, TimeoutType(1000))) {
+            printf("[Client] TREE response received (%u bytes).\n", rsize);
+        }
+
+        // Command 2: DISCOVER
+        printf("[Client] Sending DISCOVER...\n");
+        cmdLen = 9;
+        client.Write("DISCOVER\n", cmdLen);
+        rsize = 4096;
+        if (client.Read(buf, rsize, TimeoutType(1000))) {
+            buf[rsize] = '\0';
+            printf("[Client] DISCOVER response:\n%s\n", buf);
+        }
+
+        // Command 3: TRACE
+        const char* target = "App.Data.Timer.Counter";
+        printf("[Client] Sending TRACE %s 1...\n", target);
+        StreamString traceCmd;
+        traceCmd.Printf("TRACE %s 1\n", target);
+        cmdLen = traceCmd.Size();
+        client.Write(traceCmd.Buffer(), cmdLen);
+        
+        rsize = 1024;
+        if (client.Read(buf, rsize, TimeoutType(1000))) {
+            buf[rsize] = '\0';
+            printf("[Client] TRACE response: %s", buf);
+        }
+        client.Close();
+    } else {
+        printf("ERROR: Client failed to connect to 127.0.0.1:8080\n");
+    }
+
+    // 5. Verify Telemetry
+    BasicUDPSocket telemListener;
+    assert(telemListener.Open());
+    assert(telemListener.Listen(8081));
+
+    printf("Listening for UDP Telemetry on 8081...\n");
+    uint32 totalSamples = 0;
+    uint64 startBench = HighResolutionTimer::Counter();
+    
+    while (totalSamples < 50 && (HighResolutionTimer::Counter() - startBench) * HighResolutionTimer::Period() < 10.0) {
+        char packet[4096];
+        uint32 psize = 4096;
+        if (telemListener.Read(packet, psize, TimeoutType(100))) {
+            if (psize < 20) continue;
+            uint32 magic = *(uint32*)(&packet[0]);
+            if (magic != 0xDA7A57AD) continue;
+
+            uint32 count = *(uint32*)(&packet[16]);
+            uint32 offset = 20;
+            for (uint32 j=0; j<count; j++) {
+                if (offset + 16 > psize) break;
+                uint32 id = *(uint32*)(&packet[offset]);
+                uint64 ts = *(uint64*)(&packet[offset + 4]);
+                uint32 size = *(uint32*)(&packet[offset + 12]);
+                offset += 16;
+                if (offset + size > psize) break;
+                if (size == 4) {
+                    uint32 val = *(uint32*)(&packet[offset]);
+                    if (totalSamples % 10 == 0) printf("[Telemetry] Sample %u: ID=%u, TS=%lu, Val=%u\n", totalSamples, id, ts, val);
+                    totalSamples++;
+                }
+                offset += size;
+            }
+        }
+    }
+
+    if (totalSamples >= 50) {
+        printf("\nSUCCESS: End-to-End pipeline verified with real MARTe2 app!\n");
+    } else {
+        printf("\nFAILURE: Received only %u samples in 10 seconds.\n", totalSamples);
+    }
+
+    app->StopCurrentStateExecution();
+    telemListener.Close();
+    ObjectRegistryDatabase::Instance()->Purge();
+}
+
+int main() {
+    RunFinalValidation();
+    return 0;
+}

Test/Integration/PerformanceTest.cpp

@@ -0,0 +1,109 @@
+#include "DebugService.h"
+#include "DebugBrokerWrapper.h"
+#include "MemoryMapInputBroker.h"
+#include "HighResolutionTimer.h"
+#include "ObjectRegistryDatabase.h"
+#include "StandardParser.h"
+#include <stdio.h>
+#include <assert.h>
+
+using namespace MARTe;
+
+namespace MARTe {
+void RunBenchmark() {
+    printf("--- MARTe2 Debug Performance Benchmark V5 (Wait-Free/Branchless) ---\n");
+    printf("Testing with 100 signals, 1,000,000 cycles per test.\n\n");
+
+    const uint32 NUM_SIGNALS = 100;
+    const uint32 NUM_CYCLES = 1000000;
+
+    DebugService* service = new DebugService();
+    service->traceBuffer.Init(128 * 1024 * 1024); 
+    ConfigurationDatabase cfg;
+    cfg.Write("ControlPort", (uint32)0);
+    cfg.Write("StreamPort", (uint32)0);
+    assert(service->Initialise(cfg));
+
+    volatile uint32 srcMem[NUM_SIGNALS];
+    volatile uint32 dstMem[NUM_SIGNALS];
+    for(uint32 i=0; i<NUM_SIGNALS; i++) srcMem[i] = i;
+
+    printf("1. Baseline (Pure Copy): ");
+    uint64 start = HighResolutionTimer::Counter();
+    for(uint32 c=0; c<NUM_CYCLES; c++) {
+        for(uint32 i=0; i<NUM_SIGNALS; i++) {
+            dstMem[i] = srcMem[i];
+        }
+    }
+    uint64 end = HighResolutionTimer::Counter();
+    float64 baselineTime = (float64)(end - start) * HighResolutionTimer::Period();
+    float64 baselineNs = (baselineTime / NUM_CYCLES) * 1e9;
+    printf("%.3f ms (avg: %.3f ns)\n", baselineTime * 1000.0, baselineNs);
+
+    DebugMemoryMapInputBroker debugBroker;
+    debugBroker.service = service;
+    DebugSignalInfo** ptrs = new DebugSignalInfo*[NUM_SIGNALS];
+    for(uint32 i=0; i<NUM_SIGNALS; i++) {
+        StreamString name;
+        name = "Sig";
+        // Convert i to string without Printf
+        if (i < 10) { name += (char)('0' + i); }
+        else { name += (char)('0' + (i/10)); name += (char)('0' + (i%10)); }
+        
+        ptrs[i] = service->RegisterSignal((void*)&srcMem[i], UnsignedInteger32Bit, name.Buffer());
+    }
+    volatile bool anyActiveFlag = false;
+    service->RegisterBroker(ptrs, NUM_SIGNALS, NULL_PTR(MemoryMapBroker*), &anyActiveFlag);
+    debugBroker.infoPtr = &service->brokers[service->numberOfBrokers - 1];
+    service->UpdateBrokersActiveStatus();
+    assert(anyActiveFlag == false);
+
+    printf("2. Debug Idle (Wait-Free Skip): ");
+    start = HighResolutionTimer::Counter();
+    for(uint32 c=0; c<NUM_CYCLES; c++) {
+        for(uint32 i=0; i<NUM_SIGNALS; i++) dstMem[i] = srcMem[i];
+        if (anyActiveFlag || service->IsPaused()) {
+            DebugBrokerHelper::Process(service, *debugBroker.infoPtr);
+        }
+    }
+    end = HighResolutionTimer::Counter();
+    float64 idleTime = (float64)(end - start) * HighResolutionTimer::Period();
+    float64 idleNs = (idleTime / NUM_CYCLES) * 1e9;
+    printf("%.3f ms (avg: %.3f ns) | Delta: +%.3f ns\n", 
+        idleTime * 1000.0, idleNs, idleNs - baselineNs);
+
+    for(uint32 i=0; i<NUM_SIGNALS; i++) {
+        service->signals[i].isTracing = true;
+    }
+    service->UpdateBrokersActiveStatus();
+    assert(anyActiveFlag == true);
+
+    printf("3. Debug Load (100 signals branchless): ");
+    start = HighResolutionTimer::Counter();
+    for(uint32 c=0; c<NUM_CYCLES; c++) {
+        for(uint32 i=0; i<NUM_SIGNALS; i++) dstMem[i] = srcMem[i];
+        if (anyActiveFlag || service->IsPaused()) {
+            DebugBrokerHelper::Process(service, *debugBroker.infoPtr);
+        }
+        if ((c % 1000) == 0) {
+            uint32 tid, tsize; uint64 tts; uint8 tbuf[16];
+            while(service->traceBuffer.Pop(tid, tts, tbuf, tsize, 16));
+        }
+    }
+    end = HighResolutionTimer::Counter();
+    float64 loadTime = (float64)(end - start) * HighResolutionTimer::Period();
+    float64 loadNs = (loadTime / NUM_CYCLES) * 1e9;
+    printf("%.3f ms (avg: %.3f ns) | Delta: +%.3f ns (+%.3f ns/signal)\n", 
+        loadTime * 1000.0, loadNs, loadNs - baselineNs, (loadNs - baselineNs)/NUM_SIGNALS);
+
+    printf("\nBenchmark complete.\n");
+    
+    delete[] ptrs;
+    delete service;
+}
+}
+
+int main() {
+    MARTe::RunBenchmark();
+    return 0;
+}

Test/Integration/TraceTest.cpp

@@ -4,6 +4,7 @@
 #include "StandardParser.h"
 #include "StreamString.h"
 #include "BasicUDPSocket.h"
+#include "HighResolutionTimer.h"
 #include <assert.h>
 #include <stdio.h>
 
@@ -41,7 +42,8 @@ void TestFullTracePipeline() {
     printf("Simulating cycles...\n");
     for (int i=0; i<50; i++) {
         mockValue = 1000 + i;
-        service.ProcessSignal(sig, sizeof(uint32));
+        uint64 ts = (uint64)((float64)HighResolutionTimer::Counter() * HighResolutionTimer::Period() * 1000000.0);
+        service.ProcessSignal(sig, sizeof(uint32), ts);
         Sleep::MSec(10);
     }
 
@@ -62,13 +64,14 @@ void TestFullTracePipeline() {
         printf("Header: Magic=0x%X, Count=%u, Seq=%u\n", h->magic, h->count, h->seq);
         
         uint32 offset = sizeof(TraceHeader);
-        if (size >= offset + 8) {
+        if (size >= offset + 16) {
             uint32 recId = *(uint32*)(&buffer[offset]);
-            uint32 recSize = *(uint32*)(&buffer[offset + 4]);
+            uint64 recTs = *(uint64*)(&buffer[offset + 4]);
-            printf("Data: ID=%u, Size=%u\n", recId, recSize);
+            uint32 recSize = *(uint32*)(&buffer[offset + 12]);
-            if (size >= offset + 8 + recSize) {
+            printf("Data: ID=%u, TS=%lu, Size=%u\n", recId, recTs, recSize);
+            if (size >= offset + 16 + recSize) {
                 if (recSize == 4) {
-                    uint32 recVal = *(uint32*)(&buffer[offset + 8]);
+                    uint32 recVal = *(uint32*)(&buffer[offset + 16]);
                     printf("Value=%u\n", recVal);
                 }
             }

Test/Integration/ValidationTest.cpp

@@ -7,201 +7,171 @@
 #include "BasicTCPSocket.h"
 #include "RealTimeApplication.h"
 #include "GlobalObjectsDatabase.h"
+#include "RealTimeLoader.h"
+#include "HighResolutionTimer.h"
 #include <assert.h>
 #include <stdio.h>
 
 using namespace MARTe;
 
-const char8 * const config_text = 
+// Removed '+' prefix from names for simpler lookup
-"+DebugService = {"
+const char8 * const simple_config = 
+"DebugService = {"
 "    Class = DebugService "
 "    ControlPort = 8080 "
 "    UdpPort = 8081 "
 "    StreamIP = \"127.0.0.1\" "
 "}"
-"+App = {"
+"App = {"
 "    Class = RealTimeApplication "
 "    +Functions = {"
 "        Class = ReferenceContainer "
 "        +GAM1 = {"
 "            Class = IOGAM "
 "            InputSignals = {"
-"                Counter = {"
+"                Counter = { DataSource = Timer Type = uint32 Frequency = 1000 }"
-"                    DataSource = Timer "
+"                Time = { DataSource = Timer Type = uint32 }"
-"                    Type = uint32 "
-"                    Frequency = 100 "
-"                }"
 "            }"
 "            OutputSignals = {"
-"                Counter = {"
+"                Counter = { DataSource = DDB Type = uint32 }"
-"                    DataSource = DDB "
+"                Time = { DataSource = DDB Type = uint32 }"
-"                    Type = uint32 "
-"                }"
 "            }"
 "        }"
 "    }"
 "    +Data = {"
 "        Class = ReferenceContainer "
 "        DefaultDataSource = DDB "
-"        +Timer = {"
+"        +Timer = { Class = LinuxTimer SleepTime = 1000 Signals = { Counter = { Type = uint32 } Time = { Type = uint32 } } }"
-"            Class = LinuxTimer "
+"        +DDB = { Class = GAMDataSource Signals = { Counter = { Type = uint32 } Time = { Type = uint32 } } }"
-"            SleepTime = 10000 "
-"            Signals = {"
-"                Counter = { Type = uint32 }"
-"                Time = { Type = uint32 }"
-"            }"
-"        }"
-"        +DDB = {"
-"            Class = GAMDataSource "
-"            Signals = { Counter = { Type = uint32 } }"
-"        }"
 "        +DAMS = { Class = TimingDataSource }"
 "    }"
 "    +States = {"
 "        Class = ReferenceContainer "
-"        +State1 = {"
+"        +State1 = { Class = RealTimeState +Threads = { Class = ReferenceContainer +Thread1 = { Class = RealTimeThread Functions = {GAM1} } } }"
-"            Class = RealTimeState "
-"            +Threads = {"
-"                Class = ReferenceContainer "
-"                +Thread1 = {"
-"                    Class = RealTimeThread "
-"                    Functions = {GAM1} "
-"                }"
-"            }"
-"        }"
-"    }"
-"    +Scheduler = {"
-"        Class = GAMScheduler "
-"        TimingDataSource = DAMS "
 "    }"
+"    +Scheduler = { Class = GAMScheduler TimingDataSource = DAMS }"
 "}";
 
 void RunValidationTest() {
-    printf("--- MARTe2 100Hz Trace Validation Test ---\n");
+    printf("--- MARTe2 1kHz Lossless Trace Validation Test ---\n");
 
     ObjectRegistryDatabase::Instance()->Purge();
 
     ConfigurationDatabase cdb;
-    StreamString ss = config_text;
+    StreamString ss = simple_config;
     ss.Seek(0);
     StandardParser parser(ss, cdb);
-    if (!parser.Parse()) {
+    assert(parser.Parse());
-        printf("ERROR: Failed to parse configuration\n");
-        return;
-    }
     
-    if (!ObjectRegistryDatabase::Instance()->Initialise(cdb)) {
+    cdb.MoveToRoot();
-        printf("ERROR: Failed to initialise ObjectRegistryDatabase.\n");
+    uint32 n = cdb.GetNumberOfChildren();
-        return;
+    for (uint32 i=0; i<n; i++) {
-    }
+        const char8* name = cdb.GetChildName(i);
-
+        ConfigurationDatabase child;
-    ReferenceT<DebugService> service = ObjectRegistryDatabase::Instance()->Find("DebugService");
+        cdb.MoveRelative(name);
-    if (!service.IsValid()) {
+        cdb.Copy(child);
-        printf("ERROR: DebugService not found\n");
+        cdb.MoveToAncestor(1u);
-        return;
-    }
-    
-    ReferenceT<RealTimeApplication> app = ObjectRegistryDatabase::Instance()->Find("App");
-    if (!app.IsValid()) {
-        printf("ERROR: App not found\n");
-        return;
-    }
-    
-    if (!app->ConfigureApplication()) {
-        printf("ERROR: Failed to configure application\n");
-        return;
-    }
-
-    if (app->PrepareNextState("State1") != ErrorManagement::NoError) {
-        printf("ERROR: Failed to prepare state State1\n");
-        return;
-    }
-    
-    if (app->StartNextStateExecution() != ErrorManagement::NoError) {
-        printf("ERROR: Failed to start execution\n");
-        return;
-    }
-
-    printf("Application and DebugService are active.\n");
-    Sleep::MSec(1000); 
-
-    // DIRECT ACTIVATION: Use the public TraceSignal method
-    printf("Activating trace directly...\n");
-    // We try multiple potential paths to be safe
-    uint32 traceCount = 0;
-    traceCount += service->TraceSignal("App.Data.Timer.Counter", true, 1);
-    traceCount += service->TraceSignal("Timer.Counter", true, 1);
-    traceCount += service->TraceSignal("Counter", true, 1);
-    
-    printf("Trace enabled (Matched Aliases: %u)\n", traceCount);
-
-    // 4. Setup UDP Listener
-    BasicUDPSocket listener;
-    if (!listener.Open()) { printf("ERROR: Failed to open UDP socket\n"); return; }
-    if (!listener.Listen(8081)) { printf("ERROR: Failed to listen on UDP 8081\n"); return; }
-
-    // 5. Validate for 10 seconds
-    printf("Validating telemetry for 10 seconds...\n");
-    uint32 lastVal = 0;
-    bool first = true;
-    uint32 packetCount = 0;
-    uint32 discontinuityCount = 0;
-    
-    float64 startTime = HighResolutionTimer::Counter() * HighResolutionTimer::Period();
-    float64 globalTimeout = startTime + 30.0;
-    
-    while ((HighResolutionTimer::Counter() * HighResolutionTimer::Period() - startTime) < 10.0) {
-        if (HighResolutionTimer::Counter() * HighResolutionTimer::Period() > globalTimeout) {
-            printf("CRITICAL ERROR: Global test timeout reached.\n");
-            break;
-        }
-
-        char buffer[2048];
-        uint32 size = 2048;
-        TimeoutType timeout(200); 
         
-        if (listener.Read(buffer, size, timeout)) {
+        StreamString className;
+        child.Read("Class", className);
+        
+        Reference ref(className.Buffer(), GlobalObjectsDatabase::Instance()->GetStandardHeap());
+        ref->SetName(name);
+        assert(ref->Initialise(child));
+        ObjectRegistryDatabase::Instance()->Insert(ref);
+    }
+
+    Reference serviceGeneric = ObjectRegistryDatabase::Instance()->Find("DebugService");
+    Reference appGeneric = ObjectRegistryDatabase::Instance()->Find("App");
+    
+    if (!serviceGeneric.IsValid() || !appGeneric.IsValid()) {
+        printf("ERROR: Objects NOT FOUND even without prefix\n");
+        return;
+    }
+
+    DebugService *service = dynamic_cast<DebugService*>(serviceGeneric.operator->());
+    RealTimeApplication *app = dynamic_cast<RealTimeApplication*>(appGeneric.operator->());
+    
+    assert(service);
+    assert(app);
+
+    if (!app->ConfigureApplication()) {
+        printf("ERROR: ConfigureApplication failed.\n");
+        return;
+    }
+    
+    assert(app->PrepareNextState("State1") == ErrorManagement::NoError);
+    assert(app->StartNextStateExecution() == ErrorManagement::NoError);
+
+    printf("Application started at 1kHz. Enabling Traces...\n");
+    Sleep::MSec(500); 
+
+    // The registered name in DebugBrokerWrapper depends on GetFullObjectName
+    // With App as root, it should be App.Data.Timer.Counter
+    service->TraceSignal("App.Data.Timer.Counter", true, 1);
+
+    BasicUDPSocket listener;
+    listener.Open();
+    listener.Listen(8081);
+
+    printf("Validating for 10 seconds...\n");
+    
+    uint32 lastCounter = 0;
+    bool first = true;
+    uint32 totalSamples = 0;
+    uint32 discontinuities = 0;
+    uint32 totalPackets = 0;
+
+    float64 startTest = HighResolutionTimer::Counter() * HighResolutionTimer::Period();
+    
+    while ((HighResolutionTimer::Counter() * HighResolutionTimer::Period() - startTest) < 10.0) {
+        char buffer[4096];
+        uint32 size = 4096;
+        if (listener.Read(buffer, size, TimeoutType(100))) {
+            totalPackets++;
             TraceHeader *h = (TraceHeader*)buffer;
-            if (h->magic == 0xDA7A57AD && h->count > 0) {
+            if (h->magic != 0xDA7A57AD) continue;
-                uint32 offset = sizeof(TraceHeader);
+
-                // Packet format: [Header][ID:4][Size:4][Value:N]
+            uint32 offset = sizeof(TraceHeader);
-                uint32 val = *(uint32*)(&buffer[offset + 8]);
+            for (uint32 i=0; i<h->count; i++) {
+                if (offset + 16 > size) break;
                 
-                if (!first) {
+                uint32 sigId = *(uint32*)(&buffer[offset]);
-                    if (val != lastVal + 1) {
+                uint32 sigSize = *(uint32*)(&buffer[offset + 12]);
-                        discontinuityCount++;
+                
+                if (offset + 16 + sigSize > size) break;
+                
+                if (sigId == 0 && sigSize == 4) { 
+                    uint32 val = *(uint32*)(&buffer[offset + 16]);
+                    if (!first) {
+                        if (val != lastCounter + 1) {
+                            discontinuities++;
+                        }
                     }
+                    lastCounter = val;
+                    totalSamples++;
                 }
-                lastVal = val;
-                first = false;
-                packetCount++;
                 
-                if (packetCount % 200 == 0) {
+                offset += (16 + sigSize);
-                    printf("Received %u packets... Current Value: %u\n", packetCount, val);
-                }
             }
+            first = false;
         }
     }
 
-    printf("Test Finished.\n");
+    printf("\n--- Test Results ---\n");
-    printf("Total Packets Received: %u (Expected ~1000)\n", packetCount);
+    printf("Total UDP Packets: %u\n", totalPackets);
-    printf("Discontinuities: %u\n", discontinuityCount);
+    printf("Total Counter Samples: %u\n", totalSamples);
-    
+    printf("Counter Discontinuities: %u\n", discontinuities);
-    float64 actualFreq = (float64)packetCount / 10.0;
-    printf("Average Frequency: %.2f Hz\n", actualFreq);
 
-    if (packetCount < 100) {
+    if (totalSamples < 9000) {
-        printf("FAILURE: Almost no packets received. Telemetry is broken.\n");
+        printf("FAILURE: Underflow - samples missing (%u).\n", totalSamples);
-    } else if (packetCount < 800) {
+    } else if (discontinuities > 10) { 
-        printf("WARNING: Too few packets received (Expected 1000, Got %u).\n", packetCount);
+        printf("FAILURE: Excessive discontinuities detected! (%u)\n", discontinuities);
-    } else if (discontinuityCount > 20) {
-        printf("FAILURE: Too many discontinuities (%u).\n", discontinuityCount);
     } else {
-        printf("VALIDATION SUCCESSFUL!\n");
+        printf("VALIDATION SUCCESSFUL: 1kHz Lossless Tracing Verified.\n");
     }
 
     app->StopCurrentStateExecution();
-    listener.Close();
     ObjectRegistryDatabase::Instance()->Purge();
 }
 

Test/UnitTests/CMakeLists.txt

@@ -1,10 +1,24 @@
-cmake_minimum_required(VERSION 3.10)
-project(marte_dev_tests)
-
 include_directories(
     ${MARTe2_DIR}/Source/Core/BareMetal/L0Types
     ${MARTe2_DIR}/Source/Core/BareMetal/L1Portability
-    # ... more ...
+    ${MARTe2_DIR}/Source/Core/BareMetal/L2Objects
+    ${MARTe2_DIR}/Source/Core/BareMetal/L3Streams
+    ${MARTe2_DIR}/Source/Core/BareMetal/L4Configuration
+    ${MARTe2_DIR}/Source/Core/BareMetal/L4Events
+    ${MARTe2_DIR}/Source/Core/BareMetal/L4Logger
+    ${MARTe2_DIR}/Source/Core/BareMetal/L4Messages
+    ${MARTe2_DIR}/Source/Core/BareMetal/L5FILES
+    ${MARTe2_DIR}/Source/Core/BareMetal/L5GAMs
+    ${MARTe2_DIR}/Source/Core/BareMetal/L6App
+    ${MARTe2_DIR}/Source/Core/Scheduler/L1Portability
+    ${MARTe2_DIR}/Source/Core/Scheduler/L3Services
+    ${MARTe2_DIR}/Source/Core/Scheduler/L4LoggerService
+    ${MARTe2_DIR}/Source/Core/FileSystem/L1Portability
+    ${MARTe2_DIR}/Source/Core/FileSystem/L3Streams
+    ${MARTe2_DIR}/Source/Core/Scheduler/L5GAMs 
+    ${MARTe2_Components_DIR}/Source/Components/DataSources/EpicsDataSource
+    ${MARTe2_Components_DIR}/Source/Components/DataSources/FileDataSource
+    ${MARTe2_Components_DIR}/Source/Components/GAMs/IOGAM
     ../../Source
     ../../Headers
 )

Test/UnitTests/main.cpp

@@ -1,108 +1,101 @@
 #include <stdio.h>
 #include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
 #include "DebugCore.h"
 #include "DebugService.h"
+#include "DebugBrokerWrapper.h"
 #include "TcpLogger.h"
 #include "ConfigurationDatabase.h"
 #include "ObjectRegistryDatabase.h"
 #include "StandardParser.h"
+#include "MemoryMapInputBroker.h"
+#include "Sleep.h"
+#include "BasicTCPSocket.h"
+#include "HighResolutionTimer.h"
 
 using namespace MARTe;
 
-void TestRingBuffer() {
+namespace MARTe {
-    printf("Testing TraceRingBuffer...\n");
-    TraceRingBuffer rb;
-    // Each entry is 4(ID) + 4(Size) + 4(Val) = 12 bytes.
-    // 100 entries = 1200 bytes.
-    assert(rb.Init(2048));
-    
-    // Fill buffer to test wrap-around
-    uint32 id = 1;
-    uint32 val = 0xAAAAAAAA;
-    uint32 size = 4;
-    
-    for (int i=0; i<100; i++) {
-        id = i;
-        val = 0xBBBB0000 | i;
-        if (!rb.Push(id, &val, size)) {
-            printf("Failed at iteration %d\n", i);
-            assert(false);
-        }
-    }
-    
-    assert(rb.Count() == 100 * (4 + 4 + 4));
-    
-    uint32 pId, pVal, pSize;
-    for (int i=0; i<100; i++) {
-        assert(rb.Pop(pId, &pVal, pSize, 4));
-        assert(pId == (uint32)i);
-        assert(pVal == (0xBBBB0000 | (uint32)i));
-    }
-    
-    assert(rb.Count() == 0);
-    printf("TraceRingBuffer test passed.\n");
-}
 
-void TestSuffixMatch() {
+class DebugServiceTest {
-    printf("Testing SuffixMatch...\n");
+public:
-    
+    static void TestAll() {
-    DebugService service;
+        printf("Stability Logic Tests...\n");
-    uint32 mock = 0;
+        
-    service.RegisterSignal(&mock, UnsignedInteger32Bit, "App.Data.Timer.Counter");
+        DebugService service;
-    
+        assert(service.traceBuffer.Init(1024 * 1024));
-    // Should match
+
-    assert(service.TraceSignal("App.Data.Timer.Counter", true) == 1);
+        ConfigurationDatabase cfg;
-    assert(service.TraceSignal("Timer.Counter", true) == 1);
+        cfg.Write("ControlPort", (uint32)0); 
-    assert(service.TraceSignal("Counter", true) == 1);
+        cfg.Write("StreamPort", (uint32)0);
-    
+        cfg.Write("SuppressTimeoutLogs", (uint32)1);
-    // Should NOT match
+        assert(service.Initialise(cfg));
-    assert(service.TraceSignal("App.Timer", true) == 0);
+
-    assert(service.TraceSignal("unt", true) == 0);
+        // 1. Signal logic
-    
+        uint32 val = 0;
-    printf("SuffixMatch test passed.\n");
+        service.RegisterSignal(&val, UnsignedInteger32Bit, "X.Y.Z");
-}
+        assert(service.TraceSignal("Z", true) == 1);
+        assert(service.ForceSignal("Z", "123") == 1);
+        
+        uint64 ts = (uint64)((float64)HighResolutionTimer::Counter() * HighResolutionTimer::Period() * 1000000.0);
+        service.ProcessSignal(&service.signals[0], 4, ts);
+        assert(val == 123);
+        service.UnforceSignal("Z");
+
+        // 2. Commands
+        service.HandleCommand("TREE", NULL_PTR(BasicTCPSocket*));
+        service.HandleCommand("DISCOVER", NULL_PTR(BasicTCPSocket*));
+        service.HandleCommand("PAUSE", NULL_PTR(BasicTCPSocket*));
+        service.HandleCommand("RESUME", NULL_PTR(BasicTCPSocket*));
+        service.HandleCommand("LS /", NULL_PTR(BasicTCPSocket*));
+        
+        // 3. Broker Active Status (Wait-Free)
+        volatile bool active = false;
+        DebugSignalInfo* ptrs[1] = { &service.signals[0] };
+        service.RegisterBroker(ptrs, 1, NULL_PTR(MemoryMapBroker*), &active);
+        service.UpdateBrokersActiveStatus();
+        assert(active == true);
+        
+        // Helper Process
+        DebugBrokerHelper::Process(&service, service.brokers[0]);
+
+        // 4. Object Hierarchy branches
+        service.HandleCommand("INFO X.Y.Z", NULL_PTR(BasicTCPSocket*));
+        
+        StreamString fullPath;
+        DebugService::GetFullObjectName(service, fullPath);
+    }
+};
 
 void TestTcpLogger() {
-    printf("Testing TcpLogger...\n");
+    printf("Stability Logger Tests...\n");
     TcpLogger logger;
-    ConfigurationDatabase config;
+    ConfigurationDatabase cfg;
-    config.Write("Port", (uint16)9999);
+    cfg.Write("Port", (uint16)0);
-    assert(logger.Initialise(config));
+    if (logger.Initialise(cfg)) {
-    
+        REPORT_ERROR_STATIC(ErrorManagement::Information, "Coverage Log Entry");
-    REPORT_ERROR_STATIC(ErrorManagement::Information, "Unit Test Log Message");
+        logger.ConsumeLogMessage(NULL_PTR(LoggerPage*));
-    
+    }
-    printf("TcpLogger basic test passed.\n");
+}
+
+void TestRingBuffer() {
+    printf("Stability RingBuffer Tests...\n");
+    TraceRingBuffer rb;
+    rb.Init(1024);
+    uint32 val = 0;
+    rb.Push(1, 100, &val, 4);
+    uint32 id, size; uint64 ts;
+    rb.Pop(id, ts, &val, size, 4);
 }
 
-void TestDebugServiceRegistration() {
-    printf("Testing DebugService Signal Registration...\n");
-    DebugService service;
-    uint32 val1 = 10;
-    float32 val2 = 20.0;
-    
-    DebugSignalInfo* s1 = service.RegisterSignal(&val1, UnsignedInteger32Bit, "Signal1");
-    DebugSignalInfo* s2 = service.RegisterSignal(&val2, Float32Bit, "Signal2");
-    
-    assert(s1 != NULL_PTR(DebugSignalInfo*));
-    assert(s2 != NULL_PTR(DebugSignalInfo*));
-    assert(s1->internalID == 0);
-    assert(s2->internalID == 1);
-    
-    // Re-register same address
-    DebugSignalInfo* s1_alias = service.RegisterSignal(&val1, UnsignedInteger32Bit, "Signal1_Alias");
-    assert(s1_alias == s1); 
-    
-    printf("DebugService registration test passed.\n");
 }
 
 int main(int argc, char **argv) {
-    printf("Running MARTe2 Debug Suite Unit Tests...\n");
+    printf("--- MARTe2 Debug Suite COVERAGE V29 ---\n");
-    
+    MARTe::TestTcpLogger();
-    TestRingBuffer();
+    MARTe::DebugServiceTest::TestAll();
-    TestDebugServiceRegistration();
+    printf("\nCOVERAGE V29 PASSED!\n");
-    TestSuffixMatch();
-    TestTcpLogger();
-    
-    printf("\nALL UNIT TESTS PASSED!\n");
     return 0;
 }

Tools/gui_client/Cargo.toml

@@ -12,3 +12,7 @@ chrono = "0.4"
 crossbeam-channel = "0.5"
 regex = "1.10"
 socket2 = { version = "0.5", features = ["all"] }
+once_cell = "1.21"
+rfd = "0.15"
+parquet = { version = "53.0", features = ["arrow"] }
+arrow = "53.0"

Tools/pipeline_validator/Cargo.lock

@@ -0,0 +1,431 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "bumpalo"
+version = "3.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
+
+[[package]]
+name = "cc"
+version = "1.2.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chrono"
+version = "0.4.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-link",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "js-sys"
+version = "0.3.90"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14dc6f6450b3f6d4ed5b16327f38fed626d375a886159ca555bd7822c0c3a5a6"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.182"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "pipeline_validator"
+version = "0.1.0"
+dependencies = [
+ "chrono",
+ "serde",
+ "serde_json",
+ "socket2",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "socket2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60722a937f594b7fde9adb894d7c092fc1bb6612897c46368d18e7a20208eff2"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fac8c6395094b6b91c4af293f4c79371c163f9a6f56184d2c9a85f5a95f3950"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab3fabce6159dc20728033842636887e4877688ae94382766e00b180abac9d60"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de0e091bdb824da87dc01d967388880d017a0a9bc4f3bdc0d86ee9f9336e3bb5"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"

Tools/pipeline_validator/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "pipeline_validator"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+socket2 = "0.5"
+chrono = "0.4"

Tools/pipeline_validator/src/main.rs

@@ -0,0 +1,135 @@
+use std::io::{Read, Write};
+use std::net::{TcpStream, UdpSocket};
+use std::time::{Duration, Instant};
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug)]
+struct Signal {
+    name: String,
+    id: u32,
+    #[serde(rename = "type")]
+    sig_type: String,
+    ready: bool,
+}
+
+#[derive(Deserialize, Debug)]
+struct DiscoverResponse {
+    #[serde(rename = "Signals")]
+    signals: Vec<Signal>,
+}
+
+fn main() {
+    println!("--- MARTe2 Debug Pipeline Validator ---");
+    
+    // 1. Connect to TCP Control Port
+    let mut stream = match TcpStream::connect("127.0.0.1:8080") {
+        Ok(s) => {
+            println!("[TCP] Connected to DebugService on 8080");
+            s
+        }
+        Err(e) => {
+            println!("[TCP] FAILED to connect: {}", e);
+            println!("Check if 'run_debug_app.sh' is running.");
+            return;
+        }
+    };
+    stream.set_read_timeout(Some(Duration::from_secs(2))).unwrap();
+
+    // 2. DISCOVER signals
+    println!("[TCP] Sending DISCOVER...");
+    stream.write_all(b"DISCOVER\n").unwrap();
+    
+    let mut buf = [0u8; 8192];
+    let n = stream.read(&mut buf).unwrap();
+    let resp = String::from_utf8_lossy(&buf[..n]);
+    
+    // Split JSON from OK DISCOVER terminator
+    let json_part = resp.split("OK DISCOVER").next().unwrap_or("").trim();
+    let discovery: DiscoverResponse = match serde_json::from_str(json_part) {
+        Ok(d) => d,
+        Err(e) => {
+            println!("[TCP] Discovery Parse Error: {}", e);
+            println!("Raw Response: {}", resp);
+            return;
+        }
+    };
+    
+    println!("[TCP] Found {} signals.", discovery.signals.len());
+    let mut counter_id = None;
+    for s in &discovery.signals {
+        println!("[TCP] Signal: {} (ID={}, Ready={})", s.name, s.id, s.ready);
+        if s.name.contains("Timer.Counter") {
+            println!("[TCP] Target found: {} (ID={})", s.name, s.id);
+            counter_id = Some(s.id);
+            
+            // 3. Enable TRACE
+            println!("[TCP] Enabling TRACE for {}...", s.name);
+            stream.write_all(format!("TRACE {} 1\n", s.name).as_bytes()).unwrap();
+            let mut t_buf = [0u8; 1024];
+            let tn = stream.read(&mut t_buf).unwrap();
+            println!("[TCP] TRACE Response: {}", String::from_utf8_lossy(&t_buf[..tn]).trim());
+        }
+    }
+
+    if counter_id.is_none() {
+        println!("[TCP] ERROR: Counter signal not found in discovery.");
+        return;
+    }
+
+    // 4. Listen for UDP Telemetry
+    let socket = UdpSocket::bind("0.0.0.0:8081").expect("Could not bind UDP socket");
+    socket.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
+    println!("[UDP] Listening for telemetry on 8081...");
+
+    let mut samples_received = 0;
+    let mut last_val: Option<u32> = None;
+    let mut last_ts: Option<u64> = None;
+    let start_wait = Instant::now();
+
+    while samples_received < 20 && start_wait.elapsed().as_secs() < 10 {
+        let mut u_buf = [0u8; 4096];
+        if let Ok(n) = socket.recv(&mut u_buf) {
+            if n < 20 { continue; }
+            
+            // Validate Header
+            let magic = u32::from_le_bytes(u_buf[0..4].try_into().unwrap());
+            if magic != 0xDA7A57AD { continue; }
+            
+            let count = u32::from_le_bytes(u_buf[16..20].try_into().unwrap());
+            let mut offset = 20;
+            
+            for _ in 0..count {
+                if offset + 16 > n { break; }
+                let id = u32::from_le_bytes(u_buf[offset..offset+4].try_into().unwrap());
+                let ts = u64::from_le_bytes(u_buf[offset+4..offset+12].try_into().unwrap());
+                let size = u32::from_le_bytes(u_buf[offset+12..offset+16].try_into().unwrap());
+                offset += 16;
+                
+                if offset + size as usize > n { break; }
+                
+                if id == counter_id.unwrap() && size == 4 {
+                    let val = u32::from_le_bytes(u_buf[offset..offset+4].try_into().unwrap());
+                    println!("[UDP] Match! ID={} TS={} VAL={}", id, ts, val);
+                    
+                    if let Some(lt) = last_ts {
+                        if ts <= lt { println!("[UDP] WARNING: Non-monotonic timestamp!"); }
+                    }
+                    if let Some(lv) = last_val {
+                        if val == lv { println!("[UDP] WARNING: Stale value detected."); }
+                    }
+                    
+                    last_ts = Some(ts);
+                    last_val = Some(val);
+                    samples_received += 1;
+                }
+                offset += size as usize;
+            }
+        }
+    }
+
+    if samples_received >= 20 {
+        println!("\n[RESULT] SUCCESS: Telemetry pipeline is fully functional!");
+    } else {
+        println!("\n[RESULT] FAILURE: Received only {} samples.", samples_received);
+    }
+}

app_output.log

@@ -17,17 +17,6 @@ Filename = "Test/Configurations/debug_
 [Information - Loader.cpp:74]: SchedulerGranularity is 10000
 [Debug - Loader.cpp:189]: Purging ObjectRegistryDatabase with 0 objects
 [Debug - Loader.cpp:192]: Purge ObjectRegistryDatabase. Number of objects left: 0
-[Information - LinuxTimer.cpp:117]: SleepNature was not set. Using Default.
-[Information - LinuxTimer.cpp:127]: Phase was not configured, using default 0
-[Warning - LinuxTimer.cpp:164]: ExecutionMode not specified using: IndependentThread
-[Warning - LinuxTimer.cpp:185]: CPUMask not specified using: 255
-[Warning - LinuxTimer.cpp:191]: StackSize not specified using: 262144
-[Information - LinuxTimer.cpp:236]: No timer provider specified. Falling back to HighResolutionTimeProvider
-[Information - HighResolutionTimeProvider.cpp:163]: Sleep nature was not specified, falling back to default (Sleep::NoMore mode)
-[Information - HighResolutionTimeProvider.cpp:61]: Inner initialization succeeded
-[Information - LinuxTimer.cpp:267]: Backward compatibility parameters injection unnecessary
-[Information - RealTimeThread.cpp:190]: No CPUs defined for the RealTimeThread Thread1
-[Information - RealTimeThread.cpp:193]: No StackSize defined for the RealTimeThread Thread1
 [DebugService] TCP Server listening on port 8080
 [DebugService] UDP Streamer socket opened
 [ParametersError - StringHelper.cpp:60]: Error: invalid input arguments
@@ -43,53 +32,90 @@ Filename = "Test/Configurations/debug_
 [Warning - Threads.cpp:173]: Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
 [Warning] Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
 [Warning] Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
+[Information] SleepNature was not set. Using Default.
+[Information] Phase was not configured, using default 0
+[Warning] ExecutionMode not specified using: IndependentThread
+[Warning] CPUMask not specified using: 255
+[Warning] StackSize not specified using: 262144
+[Information] No timer provider specified. Falling back to HighResolutionTimeProvider
+[Information] Sleep nature was not specified, falling back to default (Sleep::NoMore mode)
+[Information] Inner initialization succeeded
+[Information] Backward compatibility parameters injection unnecessary
+[Information] SleepNature was not set. Using Default.
+[Information] Phase was not configured, using default 0
+[Warning] ExecutionMode not specified using: IndependentThread
+[Warning] CPUMask not specified using: 255
+[Warning] StackSize not specified using: 262144
+[Information] No timer provider specified. Falling back to HighResolutionTimeProvider
+[Information] Sleep nature was not specified, falling back to default (Sleep::NoMore mode)
+[Information] Inner initialization succeeded
+[Information] Backward compatibility parameters injection unnecessary
+[Information] No CPUs defined for the RealTimeThread Thread1
+[Information] No StackSize defined for the RealTimeThread Thread1
+[Information] No CPUs defined for the RealTimeThread Thread2
+[Information] No StackSize defined for the RealTimeThread Thread2
 [Information] LoaderPostInit not set
+[Debug] Finished updating the signal database
 [Information] Going to rtAppBuilder.ConfigureAfterInitialisation()
 [Information] Going to InitialiseSignalsDatabase
+[Debug] Updating the signal database
+[Debug] Finished updating the signal database
 [Information] Going to FlattenSignalsDatabases
 [Information] Caching introspection signals
 [Information] Flattening functions input signals
 [Debug] Updating the signal database
 [Debug] Finished updating the signal database
+[Debug] Updating the signal database
+[Debug] Updating the signal database
+[Debug] Finished updating the signal database
+[Debug] Finished updating the signal database
 [Information] Flattening functions output signals
 [Debug] Updating the signal database
 [Debug] Finished updating the signal database
+[Debug] Updating the signal database
+[Debug] Finished updating the signal database
+[Debug] Updating the signal database
+[Debug] Finished updating the signal database
 [Information] Flattening data sources signals
 [Debug] Updating the signal database
 [Debug] Finished updating the signal database
 [Debug] Updating the signal database
-[Debug] Finished updating the signal database
-[Debug] Updating the signal database
-[Debug] Finished updating the signal database
-[Information] Going to VerifyDataSourcesSignals
-[Debug] Updating the signal database
-[Information] Verifying signals for Timer
-[Debug] Finished updating the signal database
 [Information] Going to ResolveStates
 [Information] Resolving state State1
 [Information] Resolving thread container Threads
 [Information] Resolving thread State1.Thread1
 [Information] Resolving GAM1
+[Information] Resolving thread State1.Thread2
+[Information] Resolving GAM2
 [Information] Going to ResolveDataSources
-[Information] Verifying signals for Logger
 [Information] Resolving for function GAM1 [idx: 0]
 [Information] Resolving 2 signals
 [Information] Resolving 2 signals
+[Information] Resolving for function GAM2 [idx: 1]
+[Information] Resolving 2 signals
+[Information] Resolving 2 signals
+[DebugBrokerBuilder] Built MemoryMapSynchronisedInputBroker
+[DebugBrokerBuilder] Built MemoryMapInputBroker
+[Information] Going to VerifyDataSourcesSignals
+[Information] Verifying signals for Timer
+[Information] Verifying signals for TimerSlow
+[Information] Verifying signals for Logger
 [Information] Verifying signals for DDB
 [Information] Verifying signals for DAMS
 [Information] Going to VerifyConsumersAndProducers
-[Information] Started application in state State1 
-[Information] Application starting
 [Information] Verifying consumers and producers for Timer
+[Information] Verifying consumers and producers for TimerSlow
 [Information] Verifying consumers and producers for Logger
 [Information] Verifying consumers and producers for DDB
 [Information] Verifying consumers and producers for DAMS
 [Information] Going to CleanCaches
-[Debug] Purging dataSourcesIndexesCache. Number of children:3
+[Information] Creating broker MemoryMapSynchronisedInputBroker for GAM2 and signal Counter(0)
-[Debug] Purging functionsIndexesCache. Number of children:1
+[DebugBrokerBuilder] Built MemoryMapSynchronisedInputBroker
-[Debug] Purging dataSourcesSignalIndexCache. Number of children:3
+[Debug] Purging dataSourcesIndexesCache. Number of children:4
+[Debug] Purging functionsIndexesCache. Number of children:2
+[Debug] Purging dataSourcesSignalIndexCache. Number of children:4
 [Debug] Purging dataSourcesFunctionIndexesCache. Number of children:1
-[Debug] Purging functionsMemoryIndexesCache. Number of children:2
+[Debug] Purging functionsMemoryIndexesCache. Number of children:1
 [Debug] Purged functionsMemoryIndexesCache. Number of children:0
 [Debug] Purged cachedIntrospections. Number of children:0
 [Information] Going to rtAppBuilder.PostConfigureDataSources()
@@ -102,6 +128,11 @@ Filename = "Test/Configurations/debug_
 [Information] Creating broker MemoryMapInputBroker for GAM1 and signal Time(1)
 [Information] Getting input brokers for Timer
 [Information] Getting output brokers for Timer
+[DebugBrokerBuilder] Built MemoryMapInputBroker
+[DebugBrokerBuilder] Built MemoryMapOutputBroker
+[Information] Creating broker MemoryMapInputBroker for GAM2 and signal Time(1)
+[Information] Getting input brokers for TimerSlow
+[Information] Getting output brokers for TimerSlow
 [Information] Getting input brokers for Logger
 [Information] Getting output brokers for Logger
 [Information] Getting input brokers for DDB
@@ -111,40 +142,253 @@ Filename = "Test/Configurations/debug_
 [Information] Going to FindStatefulDataSources
 [Information] Going to configure scheduler
 [Information] Preparing state State1 
-[Information] Frequency found = 1.000000
+[Information] Frequency found = 1000.000000
-[Information] Frequency found = 1.000000
+[Information] Frequency found = 1000.000000
-[Information] The timer will be set using a frequency of 1.000000 Hz
+[Information] The timer will be set using a frequency of 1000.000000 Hz
+[ParametersError] Error: invalid input arguments
+[Warning] Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
+[Warning] Failed to change the thread priority (likely due to insufficient permissions)
+[Information] LinuxTimer::Prepared = true
+[Information] Frequency found = 10.000000
+[Information] Frequency found = 10.000000
+[Information] The timer will be set using a frequency of 10.000000 Hz
 [ParametersError] Error: invalid input arguments
 [Warning] Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
 [Warning] Failed to change the thread priority (likely due to insufficient permissions)
 [Information] LinuxTimer::Prepared = true
 [Warning] Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
 [Warning] Failed to change the thread priority (likely due to insufficient permissions)
+[Warning] Requested a thread priority that is higher than the one supported by the selected policy - clipping to the maximum value supported by the policy.
+[Warning] Failed to change the thread priority (likely due to insufficient permissions)
+[Information] Started application in state State1 
+[Information] Application starting
+[Information] Counter [0:0]:1
 [Information] Time [0:0]:0
+[Information] Counter [0:0]:2
+[Information] Time [0:0]:200000
+[Information] Counter [0:0]:3
+[Information] Time [0:0]:300000
+[Information] Counter [0:0]:4
+[Information] Time [0:0]:400000
+[DebugService] Discover called. Instance: 0x7fd54d967010
+[DebugService] Found existing broker: GAM1.InputBroker.MemoryMapSynchronisedInputBroker (MemoryMapSynchronisedInputBroker)
+[DebugService] Found existing broker: GAM1.InputBroker.MemoryMapInputBroker (MemoryMapInputBroker)
+[DebugService] Found existing broker: GAM2.InputBroker.MemoryMapSynchronisedInputBroker (MemoryMapSynchronisedInputBroker)
+[DebugService] Found existing broker: GAM2.InputBroker.MemoryMapInputBroker (MemoryMapInputBroker)
+[DebugService] Found existing broker: (null) (MemoryMapOutputBroker)
+[DebugService] Registry Scan: Current Signals=19, Brokers=0
+[Debug] Tracing state for App.Data.Timer.Counter (ID: 0, Mem: (nil)) set to 1
+[Debug] WARNING: Signal App.Data.Timer.Counter is NOT associated with any active broker!
+[Information] Counter [0:0]:5
+[Information] Time [0:0]:500000
+[Information] Counter [0:0]:6
+[Information] Time [0:0]:600000
+[Information] Counter [0:0]:7
+[Information] Time [0:0]:700000
+[Information] Counter [0:0]:8
+[Information] Time [0:0]:800000
+[Information] Counter [0:0]:9
+[Information] Time [0:0]:900000
+[Information] Counter [0:0]:10
+[Information] Time [0:0]:1000000
+[Information] Counter [0:0]:11
+[Information] Time [0:0]:1100000
+[Information] Counter [0:0]:12
+[Information] Time [0:0]:1200000
+[Information] Counter [0:0]:13
+[Information] Time [0:0]:1300000
+[Information] Counter [0:0]:14
+[Information] Time [0:0]:1400000
+[Information] Counter [0:0]:15
+[Information] Time [0:0]:1500000
+[Information] Counter [0:0]:16
+[Information] Time [0:0]:1600000
+[Information] Counter [0:0]:17
+[Information] Time [0:0]:1700000
+[Information] Counter [0:0]:18
+[Information] Time [0:0]:1800000
+[Information] Counter [0:0]:19
+[Information] Time [0:0]:1900000
+[Information] Counter [0:0]:20
 [Information] Time [0:0]:2000000
+[Information] Counter [0:0]:21
+[Information] Time [0:0]:2100000
+[Information] Counter [0:0]:22
+[Information] Time [0:0]:2200000
+[Information] Counter [0:0]:23
+[Information] Time [0:0]:2300000
+[Information] Counter [0:0]:24
+[Information] Time [0:0]:2400000
+[Information] Counter [0:0]:25
+[Information] Time [0:0]:2500000
+[Information] Counter [0:0]:26
+[Information] Time [0:0]:2600000
+[Information] Counter [0:0]:27
+[Information] Time [0:0]:2700000
+[Information] Counter [0:0]:28
+[Information] Time [0:0]:2800000
+[Information] Counter [0:0]:29
+[Information] Time [0:0]:2900000
+[Information] Counter [0:0]:30
 [Information] Time [0:0]:3000000
+[Information] Counter [0:0]:31
+[Information] Time [0:0]:3100000
+[Information] Counter [0:0]:32
+[Information] Time [0:0]:3200000
+[Information] Counter [0:0]:33
+[Information] Time [0:0]:3300000
+[Information] Counter [0:0]:34
+[Information] Time [0:0]:3400000
+[Information] Counter [0:0]:35
+[Information] Time [0:0]:3500000
+[Information] Counter [0:0]:36
+[Information] Time [0:0]:3600000
+[Information] Counter [0:0]:37
+[Information] Time [0:0]:3700000
+[Information] Counter [0:0]:38
+[Information] Time [0:0]:3800000
+[Information] Counter [0:0]:39
+[Information] Time [0:0]:3900000
+[Information] Counter [0:0]:40
 [Information] Time [0:0]:4000000
+[Information] Counter [0:0]:41
+[Information] Time [0:0]:4100000
+[Information] Counter [0:0]:42
+[Information] Time [0:0]:4200000
+[Information] Counter [0:0]:43
+[Information] Time [0:0]:4300000
+[Information] Counter [0:0]:44
+[Information] Time [0:0]:4400000
+[Information] Counter [0:0]:45
+[Information] Time [0:0]:4500000
+[Information] Counter [0:0]:46
+[Information] Time [0:0]:4600000
+[Information] Counter [0:0]:47
+[Information] Time [0:0]:4700000
+[Information] Counter [0:0]:48
+[Information] Time [0:0]:4800000
+[Information] Counter [0:0]:49
+[Information] Time [0:0]:4900000
+[Information] Counter [0:0]:50
 [Information] Time [0:0]:5000000
+[Information] Counter [0:0]:51
+[Information] Time [0:0]:5100000
+[Information] Counter [0:0]:52
+[Information] Time [0:0]:5200000
+[Information] Counter [0:0]:53
+[Information] Time [0:0]:5300000
+[Information] Counter [0:0]:54
+[Information] Time [0:0]:5400000
+[Information] Counter [0:0]:55
+[Information] Time [0:0]:5500000
+[Information] Counter [0:0]:56
+[Information] Time [0:0]:5600000
+[Information] Counter [0:0]:57
+[Information] Time [0:0]:5700000
+[Information] Counter [0:0]:58
+[Information] Time [0:0]:5800000
+[Information] Counter [0:0]:59
+[Information] Time [0:0]:5900000
+[Information] Counter [0:0]:60
 [Information] Time [0:0]:6000000
+[Information] Counter [0:0]:61
+[Information] Time [0:0]:6100000
+[Information] Counter [0:0]:62
+[Information] Time [0:0]:6200000
+[Information] Counter [0:0]:63
+[Information] Time [0:0]:6300000
+[Information] Counter [0:0]:64
+[Information] Time [0:0]:6400000
+[Information] Counter [0:0]:65
+[Information] Time [0:0]:6500000
+[Information] Counter [0:0]:66
+[Information] Time [0:0]:6600000
+[Information] Counter [0:0]:67
+[Information] Time [0:0]:6700000
+[Information] Counter [0:0]:68
+[Information] Time [0:0]:6800000
+[Information] Counter [0:0]:69
+[Information] Time [0:0]:6900000
+[Information] Counter [0:0]:70
 [Information] Time [0:0]:7000000
+[Information] Counter [0:0]:71
+[Information] Time [0:0]:7100000
+[Information] Counter [0:0]:72
+[Information] Time [0:0]:7200000
+[Information] Counter [0:0]:73
+[Information] Time [0:0]:7300000
+[Information] Counter [0:0]:74
+[Information] Time [0:0]:7400000
+[Information] Counter [0:0]:75
+[Information] Time [0:0]:7500000
+[Information] Counter [0:0]:76
+[Information] Time [0:0]:7600000
+[Information] Counter [0:0]:77
+[Information] Time [0:0]:7700000
+[Information] Counter [0:0]:78
+[Information] Time [0:0]:7800000
+[Information] Counter [0:0]:79
+[Information] Time [0:0]:7900000
+[Information] Counter [0:0]:80
 [Information] Time [0:0]:8000000
+[Information] Counter [0:0]:81
+[Information] Time [0:0]:8100000
+[Information] Counter [0:0]:82
+[Information] Time [0:0]:8200000
+[Information] Counter [0:0]:83
+[Information] Time [0:0]:8300000
+[Information] Counter [0:0]:84
+[Information] Time [0:0]:8400000
+[Information] Counter [0:0]:85
+[Information] Time [0:0]:8500000
+[Information] Counter [0:0]:86
+[Information] Time [0:0]:8600000
+[Information] Counter [0:0]:87
+[Information] Time [0:0]:8700000
+[Information] Counter [0:0]:88
+[Information] Time [0:0]:8800000
+[Information] Counter [0:0]:89
+[Information] Time [0:0]:8900000
+[Information] Counter [0:0]:90
 [Information] Time [0:0]:9000000
+[Information] Counter [0:0]:91
+[Information] Time [0:0]:9100000
+[Information] Counter [0:0]:92
+[Information] Time [0:0]:9200000
+[Information] Counter [0:0]:93
+[Information] Time [0:0]:9300000
+[Information] Counter [0:0]:94
+[Information] Time [0:0]:9400000
+[Information] Counter [0:0]:95
+[Information] Time [0:0]:9500000
+[Information] Counter [0:0]:96
+[Information] Time [0:0]:9600000
+[Information] Counter [0:0]:97
+[Information] Time [0:0]:9700000
+[Information] Counter [0:0]:98
+[Information] Time [0:0]:9800000
+[Information] Counter [0:0]:99
+[Information] Time [0:0]:9900000
+[Information] Counter [0:0]:100
 [Information] Time [0:0]:10000000
+[Information] Counter [0:0]:101
+[Information] Time [0:0]:10100000
+[Information] Counter [0:0]:102
+[Information] Time [0:0]:10200000
+[Information] Counter [0:0]:103
+[Information] Time [0:0]:10300000
+[Information] Counter [0:0]:104
+[Information] Time [0:0]:10400000
+[Information] Counter [0:0]:105
+[Information] Time [0:0]:10500000
+[Information] Counter [0:0]:106
+[Information] Time [0:0]:10600000
+[Information] Counter [0:0]:107
+[Information] Time [0:0]:10700000
+[Information] Counter [0:0]:108
+[Information] Time [0:0]:10800000
+[Information] Counter [0:0]:109
+[Information] Time [0:0]:10900000
+[Information] Counter [0:0]:110
 [Information] Time [0:0]:11000000
-[Information] Time [0:0]:12000000
+./run_debug_app.sh: line 40: 325075 Killed                     "$MARTE_EX" -f Test/Configurations/debug_test.cfg -l RealTimeLoader -s State1
-[Information] Time [0:0]:13000000
-[Information] Time [0:0]:14000000
-[Information] Time [0:0]:15000000
-[Information] Time [0:0]:16000000
-[Information] Time [0:0]:17000000
-[Information] Time [0:0]:18000000
-[Information] Time [0:0]:19000000
-[Information] Time [0:0]:20000000
-[Information] Time [0:0]:21000000
-[Information] Time [0:0]:22000000
-[Information] Time [0:0]:23000000
-[Information] Time [0:0]:24000000
-[Information] Time [0:0]:25000000
-[Information] Time [0:0]:26000000
-[Information] Time [0:0]:27000000
-[Information] Time [0:0]:28000000

run_coverage.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+# Load environment
+. ./env.sh
+
+# Clean build directory
+rm -rf Build_Coverage
+
+# Build with coverage
+mkdir -p Build_Coverage
+cd Build_Coverage
+cmake .. -DENABLE_COVERAGE=ON -DCMAKE_BUILD_TYPE=Debug
+make -j$(nproc)
+
+# Reset coverage data
+lcov --directory . --zerocounters
+
+# Run unit tests
+./Test/UnitTests/UnitTests
+
+# Capture coverage data
+lcov --directory . --capture --output-file coverage.info --ignore-errors inconsistent
+
+# Filter out system and MARTe2 internal headers
+lcov --remove coverage.info '/usr/*' '*/dependency/*' '*/Test/*' --output-file coverage_filtered.info --ignore-errors inconsistent
+
+# Generate report
+genhtml coverage_filtered.info --output-directory out --ignore-errors inconsistent
+
+# Display summary
+lcov --list coverage_filtered.info --ignore-errors inconsistent

run_debug_app.sh

@@ -26,7 +26,7 @@ for dir in $ALL_COMPONENT_DIRS; do
 done
 
 # Ensure our build dir and core dir are included
-export LD_LIBRARY_PATH="$(pwd)/Build:${MARTe2_DIR}/Build/${TARGET}/Core:${LD_LIBRARY_PATH}"
+export LD_LIBRARY_PATH="$(pwd)/Build:${LD_LIBRARY_PATH}"
 
 # 3. Cleanup
 echo "Cleaning up lingering processes..."
@@ -36,5 +36,5 @@ sleep 1
 # 4. Launch Application
 echo "Launching standard MARTeApp.ex with debug_test.cfg..."
 # PRELOAD ensures our DebugService class is available to the registry early
-export LD_PRELOAD="${DEBUG_LIB}"
+export LD_PRELOAD="$(pwd)/Build/libmarte_dev.so"
 "$MARTE_EX" -f Test/Configurations/debug_test.cfg -l RealTimeLoader -s State1