working again

.gitignore

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

Headers/DebugBrokerWrapper.h

@@ -9,7 +9,6 @@
 #include "Vector.h"
 #include "FastPollingMutexSem.h"
 #include "HighResolutionTimer.h"
-#include "Atomic.h"
 
 // Original broker headers
 #include "MemoryMapInputBroker.h"
@@ -31,37 +30,42 @@ namespace MARTe {
  */
 class DebugBrokerHelper {
 public:
-    static void Process(DebugService* service, BrokerInfo& info) {
+    static void Process(DebugService* service, DebugSignalInfo** signalInfoPointers, Vector<uint32>& activeIndices, Vector<uint32>& activeSizes, FastPollingMutexSem& activeMutex) {
         if (service == NULL_PTR(DebugService*)) return;
 
+        // Re-establish break logic
         while (service->IsPaused()) {
             Sleep::MSec(10);
         }
         
-        if (*info.anyActiveFlag) {
+        activeMutex.FastLock();
-            uint32 idx = info.currentSetIdx;
+        uint32 n = activeIndices.GetNumberOfElements();
-            BrokerActiveSet& set = info.sets[idx];
+        if (n > 0 && signalInfoPointers != NULL_PTR(DebugSignalInfo**)) {
+            // Capture timestamp ONCE per broker cycle for lowest impact
             uint64 ts = (uint64)((float64)HighResolutionTimer::Counter() * HighResolutionTimer::Period() * 1000000.0);
             
-            for (uint32 i = 0; i < set.numForced; i++) {
+            for (uint32 i = 0; i < n; i++) {
-                SignalExecuteInfo& s = set.forcedSignals[i];
+                uint32 idx = activeIndices[i];
-                DebugService::CopySignal(s.memoryAddress, s.forcedValue, s.size);
+                uint32 size = activeSizes[i];
+                DebugSignalInfo *s = signalInfoPointers[idx];
+                service->ProcessSignal(s, size, ts);
+            }
+        }
+        activeMutex.FastUnLock();
     }
 
-            for (uint32 i = 0; i < set.numTraced; i++) {
+    // Pass numCopies explicitly so we can mock it
-                SignalExecuteInfo& s = set.tracedSignals[i];
+    static void InitSignals(BrokerI* broker, DataSourceI &dataSourceIn, DebugService* &service, DebugSignalInfo** &signalInfoPointers, uint32 numCopies, MemoryMapBrokerCopyTableEntry* copyTable, const char8* functionName, SignalDirection direction, volatile bool* anyActiveFlag, Vector<uint32>* activeIndices, Vector<uint32>* activeSizes, FastPollingMutexSem* activeMutex) {
-                (void)service->traceBuffer.Push(s.internalID, ts, s.memoryAddress, s.size);
-            }
-        }
-    }
-
-    static void InitSignals(BrokerI* broker, DataSourceI &dataSourceIn, DebugService* &service, DebugSignalInfo** &signalInfoPointers, uint32 numCopies, MemoryMapBrokerCopyTableEntry* copyTable, const char8* functionName, SignalDirection direction, volatile bool* anyActiveFlag) {
         if (numCopies > 0) {
             signalInfoPointers = new DebugSignalInfo*[numCopies];
             for (uint32 i=0; i<numCopies; i++) signalInfoPointers[i] = NULL_PTR(DebugSignalInfo*);
         }
 
-        if (service == NULL_PTR(DebugService*)) service = DebugService::Instance();
+        ReferenceContainer *root = ObjectRegistryDatabase::Instance();
+        Reference serviceRef = root->Find("DebugService");
+        if (serviceRef.IsValid()) {
+            service = dynamic_cast<DebugService*>(serviceRef.operator->());
+        }
 
         if (service && (copyTable != NULL_PTR(MemoryMapBrokerCopyTableEntry*))) {
             StreamString dsPath;
@@ -71,19 +75,21 @@ public:
             for (uint32 i = 0; i < numCopies; i++) {
                 void *addr = copyTable[i].dataSourcePointer;
                 TypeDescriptor type = copyTable[i].type;
-                uint32 dsIdx = i;
-                if (mmb != NULL_PTR(MemoryMapBroker*)) dsIdx = mmb->GetDSCopySignalIndex(i);
                 
-                StreamString signalName;
+                uint32 dsIdx = i;
-                if (!dataSourceIn.GetSignalName(dsIdx, signalName)) {
+                if (mmb != NULL_PTR(MemoryMapBroker*)) {
-                    signalName.Printf("Signal_%u", dsIdx);
+                    dsIdx = mmb->GetDSCopySignalIndex(i);
                 }
 
-                StreamString dsFullName = dsPath;
+                StreamString signalName;
-                if (dsFullName.Size() > 0) dsFullName += ".";
+                if (!dataSourceIn.GetSignalName(dsIdx, signalName)) signalName = "Unknown";
-                dsFullName += signalName;
+                
+                // Register canonical name
+                StreamString dsFullName;
+                dsFullName.Printf("%s.%s", dsPath.Buffer(), signalName.Buffer());
                 service->RegisterSignal(addr, type, dsFullName.Buffer()); 
 
+                // Register alias
                 if (functionName != NULL_PTR(const char8*)) {
                     StreamString gamFullName;
                     const char8* dirStr = (direction == InputSignals) ? "In" : "Out";
@@ -91,147 +97,207 @@ public:
                     if (gamRef.IsValid()) {
                         StreamString absGamPath;
                         DebugService::GetFullObjectName(*(gamRef.operator->()), absGamPath);
-                        gamFullName = absGamPath;
+                        gamFullName.Printf("%s.%s.%s", absGamPath.Buffer(), dirStr, signalName.Buffer());
                     } else {
-                        gamFullName = functionName;
+                        gamFullName.Printf("%s.%s.%s", functionName, dirStr, signalName.Buffer());
                     }
-                    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);
+            
+            // Register broker in DebugService for optimized control
+            service->RegisterBroker(signalInfoPointers, numCopies, mmb, anyActiveFlag, activeIndices, activeSizes, activeMutex);
         }
     }
 };
 
-class DebugMemoryMapInputBroker : public MemoryMapInputBroker, public DebugBrokerI {
+/**
+ * @brief Template class to instrument any MARTe2 Broker.
+ */
+template <typename BaseClass>
+class DebugBrokerWrapper : public BaseClass {
 public:
-    DebugMemoryMapInputBroker() : MemoryMapInputBroker(), service(NULL), infoPtr(NULL), anyActive(false) {
+    DebugBrokerWrapper() : BaseClass() {
-        (void)ObjectRegistryDatabase::Instance()->Insert(Reference(this));
+        service = NULL_PTR(DebugService*);
+        signalInfoPointers = NULL_PTR(DebugSignalInfo**);
+        numSignals = 0;
+        anyActive = false;
     }
-    virtual void SetService(DebugService* s) { service = s; }
+
-    virtual bool IsLinked() const { return infoPtr != NULL; }
+    virtual ~DebugBrokerWrapper() {
+        if (signalInfoPointers) delete[] signalInfoPointers;
+    }
+
     virtual bool Execute() {
-        bool ret = MemoryMapInputBroker::Execute();
+        bool ret = BaseClass::Execute();
-        if (ret && infoPtr) DebugBrokerHelper::Process(service, *infoPtr);
+        if (ret && (anyActive || (service && service->IsPaused()))) {
+            DebugBrokerHelper::Process(service, signalInfoPointers, activeIndices, activeSizes, activeMutex);
+        }
         return ret;
     }
+
     virtual bool Init(SignalDirection direction, DataSourceI &ds, const char8 *const name, void *gamMem) {
-        bool ret = MemoryMapInputBroker::Init(direction, ds, name, gamMem);
+        bool ret = BaseClass::Init(direction, ds, name, gamMem);
         if (ret) {
-            DebugSignalInfo** sigPtrs = NULL;
+            numSignals = this->GetNumberOfCopies();
-            DebugBrokerHelper::InitSignals(this, ds, service, sigPtrs, GetNumberOfCopies(), this->copyTable, name, direction, &anyActive);
+            DebugBrokerHelper::InitSignals(this, ds, service, signalInfoPointers, numSignals, this->copyTable, name, direction, &anyActive, &activeIndices, &activeSizes, &activeMutex);
-            if (service) infoPtr = service->GetBrokerInfo(service->numberOfBrokers - 1);
         }
         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) {
+            numSignals = this->GetNumberOfCopies();
+            DebugBrokerHelper::InitSignals(this, ds, service, signalInfoPointers, numSignals, this->copyTable, name, direction, &anyActive, &activeIndices, &activeSizes, &activeMutex);
+        }
+        return ret;
+    }
+
     DebugService *service;
-    BrokerInfo* infoPtr;
+    DebugSignalInfo **signalInfoPointers;
+    uint32 numSignals;
     volatile bool anyActive;
+    Vector<uint32> activeIndices;
+    Vector<uint32> activeSizes;
+    FastPollingMutexSem activeMutex;
 };
 
-template <typename T>
+template <typename BaseClass>
-class DebugGenericBroker : public T, public DebugBrokerI {
+class DebugBrokerWrapperNoOptim : public BaseClass {
 public:
-    DebugGenericBroker() : T(), service(NULL), infoPtr(NULL), anyActive(false) {
+    DebugBrokerWrapperNoOptim() : BaseClass() {
-        (void)ObjectRegistryDatabase::Instance()->Insert(Reference(this));
+        service = NULL_PTR(DebugService*);
+        signalInfoPointers = NULL_PTR(DebugSignalInfo**);
+        numSignals = 0;
+        anyActive = false;
     }
-    virtual void SetService(DebugService* s) { service = s; }
+
-    virtual bool IsLinked() const { return infoPtr != NULL; }
+    virtual ~DebugBrokerWrapperNoOptim() {
+        if (signalInfoPointers) delete[] signalInfoPointers;
+    }
+
     virtual bool Execute() {
-        bool ret = T::Execute();
+        bool ret = BaseClass::Execute();
-        if (ret && infoPtr) DebugBrokerHelper::Process(service, *infoPtr);
+        if (ret && (anyActive || (service && service->IsPaused()))) {
+            DebugBrokerHelper::Process(service, signalInfoPointers, activeIndices, activeSizes, activeMutex);
+        }
         return ret;
     }
+
     virtual bool Init(SignalDirection direction, DataSourceI &ds, const char8 *const name, void *gamMem) {
-        bool ret = T::Init(direction, ds, name, gamMem);
+        bool ret = BaseClass::Init(direction, ds, name, gamMem);
         if (ret) {
-            DebugSignalInfo** sigPtrs = NULL;
+            numSignals = this->GetNumberOfCopies();
-            DebugBrokerHelper::InitSignals(this, ds, service, sigPtrs, this->GetNumberOfCopies(), this->copyTable, name, direction, &anyActive);
+            DebugBrokerHelper::InitSignals(this, ds, service, signalInfoPointers, numSignals, this->copyTable, name, direction, &anyActive, &activeIndices, &activeSizes, &activeMutex);
-            if (service) infoPtr = service->GetBrokerInfo(service->numberOfBrokers - 1);
         }
         return ret;
     }
+
     DebugService *service;
-    BrokerInfo* infoPtr;
+    DebugSignalInfo **signalInfoPointers;
+    uint32 numSignals;
     volatile bool anyActive;
+    Vector<uint32> activeIndices;
+    Vector<uint32> activeSizes;
+    FastPollingMutexSem activeMutex;
 };
 
-class DebugMemoryMapAsyncOutputBroker : public MemoryMapAsyncOutputBroker, public DebugBrokerI {
+class DebugMemoryMapAsyncOutputBroker : public MemoryMapAsyncOutputBroker {
 public:
-    DebugMemoryMapAsyncOutputBroker() : MemoryMapAsyncOutputBroker(), service(NULL), infoPtr(NULL), anyActive(false) {
+    DebugMemoryMapAsyncOutputBroker() : MemoryMapAsyncOutputBroker() {
-        (void)ObjectRegistryDatabase::Instance()->Insert(Reference(this));
+        service = NULL_PTR(DebugService*);
+        signalInfoPointers = NULL_PTR(DebugSignalInfo**);
+        numSignals = 0;
+        anyActive = false;
+    }
+    virtual ~DebugMemoryMapAsyncOutputBroker() {
+        if (signalInfoPointers) delete[] signalInfoPointers;
     }
-    virtual void SetService(DebugService* s) { service = s; }
-    virtual bool IsLinked() const { return infoPtr != NULL; }
     virtual bool Execute() {
         bool ret = MemoryMapAsyncOutputBroker::Execute();
-        if (ret && infoPtr) DebugBrokerHelper::Process(service, *infoPtr);
+        if (ret && (anyActive || (service && service->IsPaused()))) {
+            DebugBrokerHelper::Process(service, signalInfoPointers, activeIndices, activeSizes, activeMutex);
+        }
         return ret;
     }
-    virtual bool InitWithBufferParameters(const SignalDirection d, DataSourceI &ds, const char8* n, void* m, const uint32 nb, const ProcessorType& c, const uint32 s) {
+    virtual bool InitWithBufferParameters(const SignalDirection direction, DataSourceI &dataSourceIn, const char8 * const functionName,
-        bool ret = MemoryMapAsyncOutputBroker::InitWithBufferParameters(d, ds, n, m, nb, c, s);
+            void * const gamMemoryAddress, const uint32 numberOfBuffersIn, const ProcessorType& cpuMaskIn, const uint32 stackSizeIn) {
+        bool ret = MemoryMapAsyncOutputBroker::InitWithBufferParameters(direction, dataSourceIn, functionName, gamMemoryAddress, numberOfBuffersIn, cpuMaskIn, stackSizeIn);
         if (ret) {
-            DebugSignalInfo** sigPtrs = NULL;
+            numSignals = this->GetNumberOfCopies();
-            DebugBrokerHelper::InitSignals(this, ds, service, sigPtrs, this->GetNumberOfCopies(), this->copyTable, n, d, &anyActive);
+            DebugBrokerHelper::InitSignals(this, dataSourceIn, service, signalInfoPointers, numSignals, this->copyTable, functionName, direction, &anyActive, &activeIndices, &activeSizes, &activeMutex);
-            if (service) infoPtr = service->GetBrokerInfo(service->numberOfBrokers - 1);
         }
         return ret;
     }
     DebugService *service;
-    BrokerInfo* infoPtr;
+    DebugSignalInfo **signalInfoPointers;
+    uint32 numSignals;
     volatile bool anyActive;
+    Vector<uint32> activeIndices;
+    Vector<uint32> activeSizes;
+    FastPollingMutexSem activeMutex;
 };
 
-class DebugMemoryMapAsyncTriggerOutputBroker : public MemoryMapAsyncTriggerOutputBroker, public DebugBrokerI {
+class DebugMemoryMapAsyncTriggerOutputBroker : public MemoryMapAsyncTriggerOutputBroker {
 public:
-    DebugMemoryMapAsyncTriggerOutputBroker() : MemoryMapAsyncTriggerOutputBroker(), service(NULL), infoPtr(NULL), anyActive(false) {
+    DebugMemoryMapAsyncTriggerOutputBroker() : MemoryMapAsyncTriggerOutputBroker() {
-        (void)ObjectRegistryDatabase::Instance()->Insert(Reference(this));
+        service = NULL_PTR(DebugService*);
+        signalInfoPointers = NULL_PTR(DebugSignalInfo**);
+        numSignals = 0;
+        anyActive = false;
+    }
+    virtual ~DebugMemoryMapAsyncTriggerOutputBroker() {
+        if (signalInfoPointers) delete[] signalInfoPointers;
     }
-    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);
+        if (ret && (anyActive || (service && service->IsPaused()))) {
+            DebugBrokerHelper::Process(service, signalInfoPointers, activeIndices, activeSizes, activeMutex);
+        }
         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) {
+    virtual bool InitWithTriggerParameters(const SignalDirection direction, DataSourceI &dataSourceIn, const char8 * const functionName,
-        bool ret = MemoryMapAsyncTriggerOutputBroker::InitWithTriggerParameters(d, ds, n, m, nb, pre, post, c, s);
+            void * const gamMemoryAddress, const uint32 numberOfBuffersIn, const uint32 preTriggerBuffersIn,
+            const uint32 postTriggerBuffersIn, const ProcessorType& cpuMaskIn, const uint32 stackSizeIn) {
+        bool ret = MemoryMapAsyncTriggerOutputBroker::InitWithTriggerParameters(direction, dataSourceIn, functionName, gamMemoryAddress, numberOfBuffersIn, preTriggerBuffersIn, postTriggerBuffersIn, cpuMaskIn, stackSizeIn);
         if (ret) {
-            DebugSignalInfo** sigPtrs = NULL;
+            numSignals = this->GetNumberOfCopies();
-            DebugBrokerHelper::InitSignals(this, ds, service, sigPtrs, this->GetNumberOfCopies(), this->copyTable, n, d, &anyActive);
+            DebugBrokerHelper::InitSignals(this, dataSourceIn, service, signalInfoPointers, numSignals, this->copyTable, functionName, direction, &anyActive, &activeIndices, &activeSizes, &activeMutex);
-            if (service) infoPtr = service->GetBrokerInfo(service->numberOfBrokers - 1);
         }
         return ret;
     }
     DebugService *service;
-    BrokerInfo* infoPtr;
+    DebugSignalInfo **signalInfoPointers;
+    uint32 numSignals;
     volatile bool anyActive;
+    Vector<uint32> activeIndices;
+    Vector<uint32> activeSizes;
+    FastPollingMutexSem activeMutex;
 };
 
-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 { 
+    virtual Object *Build(HeapI* const heap) const { return new (heap) T(); }
-        return new (heap) T(); 
-    }
 };
 
+typedef DebugBrokerWrapper<MemoryMapInputBroker> DebugMemoryMapInputBroker;
+// LCOV_EXCL_START
+typedef DebugBrokerWrapper<MemoryMapOutputBroker> DebugMemoryMapOutputBroker;
+typedef DebugBrokerWrapper<MemoryMapSynchronisedInputBroker> DebugMemoryMapSynchronisedInputBroker;
+typedef DebugBrokerWrapper<MemoryMapSynchronisedOutputBroker> DebugMemoryMapSynchronisedOutputBroker;
+typedef DebugBrokerWrapperNoOptim<MemoryMapInterpolatedInputBroker> DebugMemoryMapInterpolatedInputBroker;
+typedef DebugBrokerWrapper<MemoryMapMultiBufferInputBroker> DebugMemoryMapMultiBufferInputBroker;
+typedef DebugBrokerWrapper<MemoryMapMultiBufferOutputBroker> DebugMemoryMapMultiBufferOutputBroker;
+typedef DebugBrokerWrapper<MemoryMapSynchronisedMultiBufferInputBroker> DebugMemoryMapSynchronisedMultiBufferInputBroker;
+typedef DebugBrokerWrapper<MemoryMapSynchronisedMultiBufferOutputBroker> DebugMemoryMapSynchronisedMultiBufferOutputBroker;
+// LCOV_EXCL_STOP
+
 typedef DebugBrokerBuilder<DebugMemoryMapInputBroker> DebugMemoryMapInputBrokerBuilder;
+// LCOV_EXCL_START
 typedef DebugBrokerBuilder<DebugMemoryMapOutputBroker> DebugMemoryMapOutputBrokerBuilder;
 typedef DebugBrokerBuilder<DebugMemoryMapSynchronisedInputBroker> DebugMemoryMapSynchronisedInputBrokerBuilder;
 typedef DebugBrokerBuilder<DebugMemoryMapSynchronisedOutputBroker> DebugMemoryMapSynchronisedOutputBrokerBuilder;
@@ -242,6 +308,7 @@ typedef DebugBrokerBuilder<DebugMemoryMapSynchronisedMultiBufferInputBroker> Deb
 typedef DebugBrokerBuilder<DebugMemoryMapSynchronisedMultiBufferOutputBroker> DebugMemoryMapSynchronisedMultiBufferOutputBrokerBuilder;
 typedef DebugBrokerBuilder<DebugMemoryMapAsyncOutputBroker> DebugMemoryMapAsyncOutputBrokerBuilder;
 typedef DebugBrokerBuilder<DebugMemoryMapAsyncTriggerOutputBroker> DebugMemoryMapAsyncTriggerOutputBrokerBuilder;
+// LCOV_EXCL_STOP
 
 }
 

Headers/DebugService.h

@@ -14,44 +14,20 @@
 namespace MARTe {
 
 class MemoryMapBroker;
-class DebugService;
 
-/**
+struct SignalAlias {
- * @brief Interface for instrumented brokers to allow service adoption.
+    StreamString name;
- */
+    uint32 signalIndex;
-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;
-};
+    Vector<uint32>* activeIndices;
-
+    Vector<uint32>* activeSizes;
-struct SignalAlias {
+    FastPollingMutexSem* activeMutex;
-    StreamString name;
-    uint32 signalIndex;
 };
 
 class DebugService : public ReferenceContainer, public MessageI, public EmbeddedServiceMethodBinderI {
@@ -65,23 +41,12 @@ public:
     virtual bool Initialise(StructuredDataI & data);
 
     DebugSignalInfo* RegisterSignal(void* memoryAddress, TypeDescriptor type, const char8* name);
-    
-    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);
+    void RegisterBroker(DebugSignalInfo** signalPointers, uint32 numSignals, MemoryMapBroker* broker, volatile bool* anyActiveFlag, Vector<uint32>* activeIndices, Vector<uint32>* activeSizes, FastPollingMutexSem* activeMutex);
 
     virtual ErrorManagement::ErrorType Execute(ExecutionInfo & info);
 
-    static DebugService* Instance();
-
     bool IsPaused() const { return isPaused; }
     void SetPaused(bool paused) { isPaused = paused; }
 
@@ -91,32 +56,13 @@ public:
     uint32 UnforceSignal(const char8* name);
     uint32 TraceSignal(const char8* name, bool enable, uint32 decimation = 1);
     void Discover(BasicTCPSocket *client);
-    void ListNodes(const char8* path, BasicTCPSocket *client);
     void InfoNode(const char8* path, BasicTCPSocket *client);
-
+    void ListNodes(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);
+    void UpdateBrokersActiveStatus();
+    
     uint32 ExportTree(ReferenceContainer *container, StreamString &json);
     void PatchRegistry();
     
@@ -155,14 +101,27 @@ 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;
+
+    static const uint32 MAX_BROKERS = 1024;
+    BrokerInfo brokers[MAX_BROKERS];
+    uint32 numberOfBrokers;
+
     FastPollingMutexSem mutex;
+    TraceRingBuffer traceBuffer;
 
     static const uint32 MAX_CLIENTS = 16;
     BasicTCPSocket* activeClients[MAX_CLIENTS];
     FastPollingMutexSem clientsMutex;
-};
 
-extern DebugService* GlobalDebugServiceInstance;
+    static DebugService* instance;
+};
 
 }
 

SPECS.md

@@ -1,50 +1,61 @@
 # MARTe2 Debug Suite Specifications
 
-## 1. Goal
+**Version:** 1.2  
-Implement a "Zero-Code-Change" observability layer for the MARTe2 real-time framework, providing live telemetry, signal forcing, and execution control without modifying existing application source code.
+**Status:** Active / Implemented
 
-## 2. Requirements
+## 1. Executive Summary
-### 2.1 Functional Requirements (FR)
+This project implements a "Zero-Code-Change" observability and debugging layer for the MARTe2 real-time framework. The system allows developers to Trace, Force, and Monitor any signal in a running MARTe2 application without modifying existing source code.
-- **FR-01 (Discovery):** Discover the full MARTe2 object hierarchy at runtime.
+
-- **FR-02 (Telemetry):** Stream high-frequency signal data (verified up to 100Hz) to a remote client.
+## 2. System Architecture
+- **The Universal Debug Service (C++ Core):** A singleton MARTe2 Object that patches the registry and manages communication.
+- **The Broker Injection Layer (C++ Templates):** Templated wrappers that intercept `Execute()` and `Init()` calls for tracing, forcing, and execution control.
+- **The Remote Analyser (Rust/egui):** A high-performance, multi-threaded GUI for visualization and control.
+- **Network Stack:**
+    - **Port 8080 (TCP):** Commands and Metadata.
+    - **Port 8081 (UDP):** High-Speed Telemetry for Oscilloscope.
+    - **Port 8082 (TCP):** Independent Real-Time Log Stream via `TcpLogger`.
+
+## 3. Requirements
+
+### 3.1 Functional Requirements (FR)
+- **FR-01 (Discovery):** Discover the full MARTe2 object hierarchy at runtime. The GUI client SHALL request the full application tree upon connection and display it in a hierarchical tree view.
+- **FR-02 (Telemetry):** Stream high-frequency signal data (verified up to 100Hz+) to a remote client via UDP.
 - **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-04 (Logs):** Stream global framework logs to a dedicated terminal/client via a standalone `TcpLogger` service.
 - **FR-05 (Log Filtering):** The client must support filtering logs by type (Debug, Information, Warning, FatalError) and by content using regular expressions.
-- **FR-06 (Execution & UI):** 
+- **FR-06 (Execution Control):** Provide a mechanism to pause and resume the execution of all patched real-time threads (via Brokers), allowing for static inspection of the system state.
-    - Provide a native GUI for visualization.
+- **FR-07 (Session Management):** Support runtime re-configuration and "Apply & Reconnect" logic. The GUI provides a "Disconnect" button to close active network streams.
-    - Support Pause/Resume of real-time execution threads via scheduler injection.
+- **FR-08 (Decoupled Tracing):** Tracing activates telemetry; data is buffered and shown as a "Last Value" in the sidebar, but not plotted until manually assigned.
-- **FR-07 (Session Management):** 
+- **FR-09 (Advanced Plotting):** 
-    - 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-10 (Navigation & Scope):** 
-- **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.
+    - "Fit to View" functionality that automatically scales both axes.
-- **FR-10 (Scope Mode):**
     - High-performance oscilloscope mode with configurable time windows (10ms to 10s).
-    - Global synchronization of time axes across all plot panels.
+    - Triggered acquisition (Single/Continuous, rising/falling edges).
-    - 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 with a visual recording indicator in the GUI.
-- **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)
+### 3.2 Technical Constraints (TC)
 - **TC-01:** No modifications allowed to the MARTe2 core library or component source code.
 - **TC-02:** Instrumentation must use Runtime Class Registry Patching.
 - **TC-03:** Real-time threads must remain lock-free; use `FastPollingMutexSem` or atomic operations for synchronization.
 - **TC-04:** Telemetry must be delivered via UDP to minimize impact on real-time jitter.
 
-## 3. Performance Metrics
+## 4. Performance Metrics
 - **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.
+
+## 5. Communication Protocol (Port 8080)
+- **LS [Path]:** List nodes at the specified path.
+- **TREE:** Returns a full recursive JSON structure representing the entire application tree.
+- **INFO [Path]:** Returns detailed metadata for a specific node or signal.
+- **PAUSE / RESUME:** Global execution control.
+- **TRACE <Signal> <1/0> [Decimation]:** Enable/disable telemetry for a signal.
+- **FORCE <Signal> <Value>:** Persistent signal override.
+- **UNFORCE <Signal>:** Remove override.
+- **LOG <Level> <Msg>:** Streaming format used on Port 8082.

Source/DebugService.cpp

@@ -10,11 +10,23 @@
 #include "HighResolutionTimer.h"
 #include "ConfigurationDatabase.h"
 #include "GAM.h"
-#include "Atomic.h"
+
+// Explicitly include target brokers for templating
+#include "MemoryMapInputBroker.h"
+#include "MemoryMapOutputBroker.h"
+#include "MemoryMapSynchronisedInputBroker.h"
+#include "MemoryMapSynchronisedOutputBroker.h"
+#include "MemoryMapInterpolatedInputBroker.h"
+#include "MemoryMapMultiBufferInputBroker.h"
+#include "MemoryMapMultiBufferOutputBroker.h"
+#include "MemoryMapSynchronisedMultiBufferInputBroker.h"
+#include "MemoryMapSynchronisedMultiBufferOutputBroker.h"
+#include "MemoryMapAsyncOutputBroker.h"
+#include "MemoryMapAsyncTriggerOutputBroker.h"
 
 namespace MARTe {
 
-DebugService* GlobalDebugServiceInstance = NULL_PTR(DebugService*);
+DebugService* DebugService::instance = NULL_PTR(DebugService*);
 
 static void EscapeJson(const char8* src, StreamString &dst) {
     if (src == NULL_PTR(const char8*)) return;
@@ -29,12 +41,215 @@ static void EscapeJson(const char8* src, StreamString &dst) {
     }
 }
 
-static bool SuffixMatch(const char8* target, const char8* pattern) {
+CLASS_REGISTER(DebugService, "1.0")
-    uint32 tLen = StringHelper::Length(target); uint32 pLen = StringHelper::Length(pattern);
+
-    if (pLen > tLen) return false;
+DebugService::DebugService() : 
-    const char8* suffix = target + (tLen - pLen);
+    ReferenceContainer(), EmbeddedServiceMethodBinderI(),
-    if (StringHelper::Compare(suffix, pattern) == 0) { if (tLen == pLen || *(suffix - 1) == '.') return true; }
+    binderServer(this, ServiceBinder::ServerType), 
-    return false;
+    binderStreamer(this, ServiceBinder::StreamerType),
+    threadService(binderServer),
+    streamerService(binderStreamer)
+{
+    controlPort = 0;
+    streamPort = 8081; 
+    streamIP = "127.0.0.1";
+    numberOfSignals = 0;
+    numberOfAliases = 0;
+    numberOfBrokers = 0;
+    isServer = false;
+    suppressTimeoutLogs = true; 
+    isPaused = false;
+    for (uint32 i=0; i<MAX_CLIENTS; i++) {
+        activeClients[i] = NULL_PTR(BasicTCPSocket*);
+    }
+}
+
+DebugService::~DebugService() {
+    if (instance == this) {
+        instance = NULL_PTR(DebugService*);
+    }
+    threadService.Stop();
+    streamerService.Stop();
+    tcpServer.Close();
+    udpSocket.Close();
+    for (uint32 i=0; i<MAX_CLIENTS; i++) {
+        if (activeClients[i] != NULL_PTR(BasicTCPSocket*)) {
+            activeClients[i]->Close();
+            delete activeClients[i];
+        }
+    }
+}
+
+bool DebugService::Initialise(StructuredDataI & data) {
+    if (!ReferenceContainer::Initialise(data)) return false;
+    if (!data.Read("ControlPort", controlPort)) {
+        (void)data.Read("TcpPort", controlPort);
+    }
+    if (controlPort > 0) {
+        isServer = true;
+        instance = this; 
+    }
+    if (!data.Read("StreamPort", streamPort)) {
+        (void)data.Read("UdpPort", streamPort);
+    }
+    StreamString tempIP;
+    if (data.Read("StreamIP", tempIP)) {
+        streamIP = tempIP;
+    } else {
+        streamIP = "127.0.0.1";
+    }
+    uint32 suppress = 1;
+    if (data.Read("SuppressTimeoutLogs", suppress)) {
+        suppressTimeoutLogs = (suppress == 1);
+    }
+    if (isServer) {
+        if (!traceBuffer.Init(8 * 1024 * 1024)) return false;
+        PatchRegistry();
+        ConfigurationDatabase threadData;
+        threadData.Write("Timeout", (uint32)1000);
+        threadService.Initialise(threadData);
+        streamerService.Initialise(threadData);
+        if (!tcpServer.Open()) return false;
+        if (!tcpServer.Listen(controlPort)) return false;
+        printf("[DebugService] TCP Server listening on port %u\n", controlPort);
+        if (!udpSocket.Open()) return false;
+        printf("[DebugService] UDP Streamer socket opened\n");
+        if (threadService.Start() != ErrorManagement::NoError) return false;
+        if (streamerService.Start() != ErrorManagement::NoError) return false;
+        printf("[DebugService] Worker threads started.\n");
+    }
+    return true;
+}
+
+void PatchItemInternal(const char8* className, ObjectBuilder* builder) {
+    ClassRegistryDatabase *db = ClassRegistryDatabase::Instance();
+    ClassRegistryItem *item = (ClassRegistryItem*)db->Find(className);
+    if (item != NULL_PTR(ClassRegistryItem*)) {
+        item->SetObjectBuilder(builder);
+    }
+}
+
+void DebugService::PatchRegistry() {
+    DebugMemoryMapInputBrokerBuilder* b1 = new DebugMemoryMapInputBrokerBuilder(); PatchItemInternal("MemoryMapInputBroker", b1);
+    DebugMemoryMapOutputBrokerBuilder* b2 = new DebugMemoryMapOutputBrokerBuilder(); PatchItemInternal("MemoryMapOutputBroker", b2);
+    DebugMemoryMapSynchronisedInputBrokerBuilder* b3 = new DebugMemoryMapSynchronisedInputBrokerBuilder(); PatchItemInternal("MemoryMapSynchronisedInputBroker", b3);
+    DebugMemoryMapSynchronisedOutputBrokerBuilder* b4 = new DebugMemoryMapSynchronisedOutputBrokerBuilder(); PatchItemInternal("MemoryMapSynchronisedOutputBroker", b4);
+    DebugMemoryMapInterpolatedInputBrokerBuilder* b5 = new DebugMemoryMapInterpolatedInputBrokerBuilder(); PatchItemInternal("MemoryMapInterpolatedInputBroker", b5);
+    DebugMemoryMapMultiBufferInputBrokerBuilder* b6 = new DebugMemoryMapMultiBufferInputBrokerBuilder(); PatchItemInternal("MemoryMapMultiBufferInputBroker", b6);
+    DebugMemoryMapMultiBufferOutputBrokerBuilder* b7 = new DebugMemoryMapMultiBufferOutputBrokerBuilder(); PatchItemInternal("MemoryMapMultiBufferOutputBroker", b7);
+    DebugMemoryMapSynchronisedMultiBufferInputBrokerBuilder* b8 = new DebugMemoryMapSynchronisedMultiBufferInputBrokerBuilder(); PatchItemInternal("MemoryMapSynchronisedMultiBufferInputBroker", b8);
+    DebugMemoryMapSynchronisedMultiBufferOutputBrokerBuilder* b9 = new DebugMemoryMapSynchronisedMultiBufferOutputBrokerBuilder(); PatchItemInternal("MemoryMapSynchronisedMultiBufferOutputBroker", b9);
+    DebugMemoryMapAsyncOutputBrokerBuilder* b10 = new DebugMemoryMapAsyncOutputBrokerBuilder(); PatchItemInternal("MemoryMapAsyncOutputBroker", b10);
+    DebugMemoryMapAsyncTriggerOutputBrokerBuilder* b11 = new DebugMemoryMapAsyncTriggerOutputBrokerBuilder(); PatchItemInternal("MemoryMapAsyncTriggerOutputBroker", b11);
+}
+
+void DebugService::ProcessSignal(DebugSignalInfo* s, uint32 size, uint64 timestamp) {
+    if (s != NULL_PTR(DebugSignalInfo*)) {
+        if (s->isForcing) {
+            MemoryOperationsHelper::Copy(s->memoryAddress, s->forcedValue, size);
+        }
+        if (s->isTracing) {
+            if (s->decimationFactor <= 1) {
+                (void)traceBuffer.Push(s->internalID, timestamp, s->memoryAddress, size);
+            }
+            else {
+                if (s->decimationCounter == 0) {
+                    (void)traceBuffer.Push(s->internalID, timestamp, s->memoryAddress, size);
+                    s->decimationCounter = s->decimationFactor - 1;
+                }
+                else {
+                    s->decimationCounter--;
+                }
+            }
+        }
+    }
+}
+
+void DebugService::RegisterBroker(DebugSignalInfo** signalPointers, uint32 numSignals, MemoryMapBroker* broker, volatile bool* anyActiveFlag, Vector<uint32>* activeIndices, Vector<uint32>* activeSizes, FastPollingMutexSem* activeMutex) {
+    mutex.FastLock();
+    if (numberOfBrokers < MAX_BROKERS) {
+        brokers[numberOfBrokers].signalPointers = signalPointers;
+        brokers[numberOfBrokers].numSignals = numSignals;
+        brokers[numberOfBrokers].broker = broker;
+        brokers[numberOfBrokers].anyActiveFlag = anyActiveFlag;
+        brokers[numberOfBrokers].activeIndices = activeIndices;
+        brokers[numberOfBrokers].activeSizes = activeSizes;
+        brokers[numberOfBrokers].activeMutex = activeMutex;
+        numberOfBrokers++;
+    }
+    mutex.FastUnLock();
+}
+
+void DebugService::UpdateBrokersActiveStatus() {
+    // Already locked by caller (TraceSignal, ForceSignal, etc.)
+    for (uint32 i = 0; i < numberOfBrokers; i++) {
+        uint32 count = 0;
+        for (uint32 j = 0; j < brokers[i].numSignals; j++) {
+            DebugSignalInfo *s = brokers[i].signalPointers[j];
+            if (s != NULL_PTR(DebugSignalInfo*) && (s->isTracing || s->isForcing)) {
+                count++;
+            }
+        }
+        
+        Vector<uint32> tempInd(count);
+        Vector<uint32> tempSizes(count);
+        uint32 idx = 0;
+        for (uint32 j = 0; j < brokers[i].numSignals; j++) {
+            DebugSignalInfo *s = brokers[i].signalPointers[j];
+            if (s != NULL_PTR(DebugSignalInfo*) && (s->isTracing || s->isForcing)) {
+                tempInd[idx] = j;
+                tempSizes[idx] = (brokers[i].broker != NULL_PTR(MemoryMapBroker*)) ? brokers[i].broker->GetCopyByteSize(j) : 4;
+                idx++;
+            }
+        }
+        
+        if (brokers[i].activeMutex) brokers[i].activeMutex->FastLock();
+        
+        if (brokers[i].activeIndices) *(brokers[i].activeIndices) = tempInd;
+        if (brokers[i].activeSizes) *(brokers[i].activeSizes) = tempSizes;
+        if (brokers[i].anyActiveFlag) *(brokers[i].anyActiveFlag) = (count > 0);
+        
+        if (brokers[i].activeMutex) brokers[i].activeMutex->FastUnLock();
+    }
+}
+
+DebugSignalInfo* DebugService::RegisterSignal(void* memoryAddress, TypeDescriptor type, const char8* name) {
+    mutex.FastLock();
+    DebugSignalInfo* res = NULL_PTR(DebugSignalInfo*);
+    uint32 sigIdx = 0xFFFFFFFF;
+    for(uint32 i=0; i<numberOfSignals; i++) {
+        if(signals[i].memoryAddress == memoryAddress) {
+            res = &signals[i];
+            sigIdx = i;
+            break;
+        }
+    }
+    if (res == NULL_PTR(DebugSignalInfo*) && numberOfSignals < MAX_SIGNALS) {
+        sigIdx = numberOfSignals;
+        res = &signals[numberOfSignals];
+        res->memoryAddress = memoryAddress;
+        res->type = type;
+        res->name = name; 
+        res->isTracing = false;
+        res->isForcing = false;
+        res->internalID = numberOfSignals;
+        res->decimationFactor = 1;
+        res->decimationCounter = 0;
+        numberOfSignals++;
+    }
+    if (sigIdx != 0xFFFFFFFF && numberOfAliases < MAX_ALIASES) {
+        bool foundAlias = false;
+        for (uint32 i=0; i<numberOfAliases; i++) {
+            if (aliases[i].name == name) { foundAlias = true; break; }
+        }
+        if (!foundAlias) {
+            aliases[numberOfAliases].name = name;
+            aliases[numberOfAliases].signalIndex = sigIdx;
+            numberOfAliases++;
+        }
+    }
+    mutex.FastUnLock();
+    return res;
 }
 
 static bool RecursiveGetFullObjectName(ReferenceContainer *container, const Object &obj, StreamString &path) {
@@ -61,55 +276,6 @@ bool DebugService::GetFullObjectName(const Object &obj, StreamString &fullPath)
     return false;
 }
 
-CLASS_REGISTER(DebugService, "1.0")
-
-DebugService* DebugService::Instance() {
-    return GlobalDebugServiceInstance;
-}
-
-void PatchItemInternal(const char8* className, ObjectBuilder* builder) {
-    ClassRegistryDatabase *db = ClassRegistryDatabase::Instance();
-    ClassRegistryItem *item = (ClassRegistryItem*)db->Find(className);
-    if (item != NULL_PTR(ClassRegistryItem*)) {
-        item->SetObjectBuilder(builder);
-    }
-}
-
-uint32 DebugService::ForceSignal(const char8* name, const char8* valueStr) {
-    mutex.FastLock(); uint32 count = 0;
-    for (uint32 i = 0; i < numberOfAliases; i++) {
-        if (aliases[i].name == name || SuffixMatch(aliases[i].name.Buffer(), name)) {
-            DebugSignalInfo &s = signals[aliases[i].signalIndex]; s.isForcing = true;
-            AnyType dest(s.type, 0u, s.forcedValue); AnyType source(CharString, 0u, valueStr); (void)TypeConvert(dest, source);
-            count++;
-        }
-    }
-    mutex.FastUnLock(); return count;
-}
-
-uint32 DebugService::UnforceSignal(const char8* name) {
-    mutex.FastLock(); uint32 count = 0;
-    for (uint32 i = 0; i < numberOfAliases; i++) {
-        if (aliases[i].name == name || SuffixMatch(aliases[i].name.Buffer(), name)) { signals[aliases[i].signalIndex].isForcing = false; count++; }
-    }
-    mutex.FastUnLock(); return count;
-}
-
-uint32 DebugService::TraceSignal(const char8* name, bool enable, uint32 decimation) {
-    mutex.FastLock(); uint32 count = 0;
-    for (uint32 i = 0; i < numberOfAliases; i++) {
-        if (aliases[i].name == name || SuffixMatch(aliases[i].name.Buffer(), name)) {
-            uint32 sigIdx = aliases[i].signalIndex;
-            DebugSignalInfo &s = signals[sigIdx]; 
-            s.isTracing = enable; 
-            s.decimationFactor = decimation; 
-            s.decimationCounter = 0; 
-            count++;
-        }
-    }
-    mutex.FastUnLock(); return count;
-}
-
 ErrorManagement::ErrorType DebugService::Execute(ExecutionInfo & info) {
     return ErrorManagement::FatalError;
 }
@@ -118,9 +284,10 @@ ErrorManagement::ErrorType DebugService::Server(ExecutionInfo & info) {
     if (info.GetStage() == ExecutionInfo::TerminationStage) return ErrorManagement::NoError;
     if (info.GetStage() == ExecutionInfo::StartupStage) { serverThreadId = Threads::Id(); return ErrorManagement::NoError; }
     while (info.GetStage() == ExecutionInfo::MainStage) {
-        BasicTCPSocket *newClient = tcpServer.WaitConnection(10); 
+        BasicTCPSocket *newClient = tcpServer.WaitConnection(1); 
         if (newClient != NULL_PTR(BasicTCPSocket *)) {
-            clientsMutex.FastLock(); bool added = false;
+            clientsMutex.FastLock();
+            bool added = false;
             for (uint32 i=0; i<MAX_CLIENTS; i++) { if (activeClients[i] == NULL_PTR(BasicTCPSocket*)) { activeClients[i] = newClient; added = true; break; } }
             clientsMutex.FastUnLock();
             if (!added) { newClient->Close(); delete newClient; }
@@ -174,222 +341,12 @@ ErrorManagement::ErrorType DebugService::Streamer(ExecutionInfo & info) {
     return ErrorManagement::NoError;
 }
 
-DebugService::DebugService() : 
+static bool SuffixMatch(const char8* target, const char8* pattern) {
-    ReferenceContainer(), EmbeddedServiceMethodBinderI(),
+    uint32 tLen = StringHelper::Length(target); uint32 pLen = StringHelper::Length(pattern);
-    binderServer(this, ServiceBinder::ServerType), 
+    if (pLen > tLen) return false;
-    binderStreamer(this, ServiceBinder::StreamerType),
+    const char8* suffix = target + (tLen - pLen);
-    threadService(binderServer),
+    if (StringHelper::Compare(suffix, pattern) == 0) { if (tLen == pLen || *(suffix - 1) == '.') return true; }
-    streamerService(binderStreamer)
+    return false;
-{
-    GlobalDebugServiceInstance = this;
-    controlPort = 0;
-    streamPort = 8081; 
-    streamIP = "127.0.0.1";
-    numberOfSignals = 0;
-    numberOfAliases = 0;
-    numberOfBrokers = 0;
-    isServer = false;
-    suppressTimeoutLogs = true; 
-    isPaused = false;
-    for (uint32 i=0; i<MAX_CLIENTS; i++) {
-        activeClients[i] = NULL_PTR(BasicTCPSocket*);
-    }
-}
-
-// Forced patching on library load
-__attribute__((constructor))
-static void GlobalDebugSuiteInit() {
-    typedef DebugBrokerBuilder<DebugMemoryMapInputBroker> B1; PatchItemInternal("MemoryMapInputBroker", new B1());
-    typedef DebugBrokerBuilder<DebugMemoryMapOutputBroker> B2; PatchItemInternal("MemoryMapOutputBroker", new B2());
-    
-    typedef DebugBrokerBuilder<DebugMemoryMapSynchronisedInputBroker> B3; PatchItemInternal("MemoryMapSynchronisedInputBroker", new B3());
-    typedef DebugBrokerBuilder<DebugMemoryMapSynchronisedOutputBroker> B4; PatchItemInternal("MemoryMapSynchronisedOutputBroker", new B4());
-    
-    typedef DebugBrokerBuilder<DebugMemoryMapInterpolatedInputBroker> B5; PatchItemInternal("MemoryMapInterpolatedInputBroker", new B5());
-}
-
-DebugService::~DebugService() {
-    if (GlobalDebugServiceInstance == this) GlobalDebugServiceInstance = NULL_PTR(DebugService*);
-    threadService.Stop(); streamerService.Stop();
-    tcpServer.Close(); udpSocket.Close();
-    for (uint32 i=0; i<MAX_CLIENTS; i++) {
-        if (activeClients[i] != NULL_PTR(BasicTCPSocket*)) { activeClients[i]->Close(); delete activeClients[i]; }
-    }
-    for (uint32 i=0; i<numberOfBrokers; i++) {
-        for (uint32 j=0; j<2; j++) {
-            if (brokers[i].sets[j].forcedSignals) delete[] brokers[i].sets[j].forcedSignals;
-            if (brokers[i].sets[j].tracedSignals) delete[] brokers[i].sets[j].tracedSignals;
-        }
-    }
-}
-
-bool DebugService::Initialise(StructuredDataI & data) {
-    if (!ReferenceContainer::Initialise(data)) return false;
-    if (!data.Read("ControlPort", controlPort)) (void)data.Read("TcpPort", controlPort);
-    if (controlPort > 0) { isServer = true; GlobalDebugServiceInstance = this; }
-    if (!data.Read("StreamPort", streamPort)) (void)data.Read("UdpPort", streamPort);
-    StreamString tempIP; if (data.Read("StreamIP", tempIP)) streamIP = tempIP; else streamIP = "127.0.0.1";
-    uint32 suppress = 1; if (data.Read("SuppressTimeoutLogs", suppress)) suppressTimeoutLogs = (suppress == 1);
-    
-    if (isServer) {
-        if (!traceBuffer.Init(8 * 1024 * 1024)) return false;
-        ConfigurationDatabase threadData; threadData.Write("Timeout", (uint32)1000);
-        threadService.Initialise(threadData); streamerService.Initialise(threadData);
-        if (!tcpServer.Open()) return false;
-        if (!tcpServer.Listen(controlPort)) return false;
-        printf("[DebugService] TCP Server listening on port %u\n", controlPort);
-        if (!udpSocket.Open()) return false;
-        printf("[DebugService] UDP Streamer socket opened\n");
-        if (threadService.Start() != ErrorManagement::NoError) return false;
-        if (streamerService.Start() != ErrorManagement::NoError) return false;
-        printf("[DebugService] Worker threads started.\n");
-    }
-    return true;
-}
-
-void DebugService::PatchRegistry() {
-}
-
-void DebugService::ProcessSignal(DebugSignalInfo* s, uint32 size, uint64 timestamp) {
-    if (s == NULL_PTR(DebugSignalInfo*)) return;
-    if (s->isForcing) CopySignal(s->memoryAddress, s->forcedValue, size);
-    if (s->isTracing) {
-        if (s->decimationFactor <= 1) (void)traceBuffer.Push(s->internalID, timestamp, s->memoryAddress, size);
-        else {
-            if (s->decimationCounter == 0) { (void)traceBuffer.Push(s->internalID, timestamp, s->memoryAddress, size); s->decimationCounter = s->decimationFactor - 1; }
-            else s->decimationCounter--;
-        }
-    }
-}
-
-void DebugService::RegisterBroker(DebugSignalInfo** signalPointers, uint32 numSignals, MemoryMapBroker* broker, volatile bool* anyActiveFlag) {
-    mutex.FastLock();
-    for (uint32 i=0; i<numberOfBrokers; i++) { if (brokers[i].broker == broker) { mutex.FastUnLock(); return; } }
-    if (numberOfBrokers < MAX_BROKERS) {
-        printf("[DebugService] Registering Broker %u (%u signals, anyActiveFlag=%p)\n", numberOfBrokers, numSignals, (void*)anyActiveFlag);
-        brokers[numberOfBrokers].signalPointers = signalPointers;
-        brokers[numberOfBrokers].numSignals = numSignals;
-        brokers[numberOfBrokers].broker = broker;
-        brokers[numberOfBrokers].anyActiveFlag = anyActiveFlag;
-        brokers[numberOfBrokers].currentSetIdx = 0;
-        for (uint32 j=0; j<2; j++) {
-            brokers[numberOfBrokers].sets[j].numForced = 0; brokers[numberOfBrokers].sets[j].numTraced = 0;
-            brokers[numberOfBrokers].sets[j].forcedSignals = NULL_PTR(SignalExecuteInfo*); brokers[numberOfBrokers].sets[j].tracedSignals = NULL_PTR(SignalExecuteInfo*);
-        }
-        numberOfBrokers++;
-    }
-    mutex.FastUnLock();
-}
-
-static void AdoptOrphans(ReferenceContainer *container, DebugService* service) {
-    if (!container) return;
-    for (uint32 i=0; i<container->Size(); i++) {
-        Reference child = container->Get(i);
-        if (child.IsValid()) {
-            DebugBrokerI* b = dynamic_cast<DebugBrokerI*>(child.operator->());
-            if (b && !b->IsLinked()) {
-                b->SetService(service);
-            }
-            ReferenceContainer *inner = dynamic_cast<ReferenceContainer*>(child.operator->());
-            if (inner) AdoptOrphans(inner, service);
-        }
-    }
-}
-
-void DebugService::UpdateBrokersActiveStatus() {
-    AdoptOrphans(ObjectRegistryDatabase::Instance(), this);
-    for (uint32 i = 0; i < numberOfBrokers; i++) {
-        uint32 nextIdx = (brokers[i].currentSetIdx + 1) % 2;
-        BrokerActiveSet& nextSet = brokers[i].sets[nextIdx];
-        uint32 forcedCount = 0; uint32 tracedCount = 0;
-        for (uint32 j = 0; j < brokers[i].numSignals; j++) {
-            DebugSignalInfo *s = brokers[i].signalPointers[j];
-            if (s != NULL_PTR(DebugSignalInfo*)) {
-                if (s->isForcing) forcedCount++;
-                if (s->isTracing) tracedCount++;
-            }
-        }
-        SignalExecuteInfo* newForced = (forcedCount > 0) ? new SignalExecuteInfo[forcedCount] : NULL_PTR(SignalExecuteInfo*);
-        SignalExecuteInfo* newTraced = (tracedCount > 0) ? new SignalExecuteInfo[tracedCount] : NULL_PTR(SignalExecuteInfo*);
-        uint32 fIdx = 0; uint32 tIdx = 0;
-        for (uint32 j = 0; j < brokers[i].numSignals; j++) {
-            DebugSignalInfo *s = brokers[i].signalPointers[j];
-            if (s != NULL_PTR(DebugSignalInfo*)) {
-                uint32 size = (brokers[i].broker != NULL_PTR(MemoryMapBroker*)) ? brokers[i].broker->GetCopyByteSize(j) : 4;
-                if (s->isForcing) { newForced[fIdx].memoryAddress = s->memoryAddress; newForced[fIdx].forcedValue = s->forcedValue; newForced[fIdx].size = size; fIdx++; }
-                if (s->isTracing) { newTraced[tIdx].memoryAddress = s->memoryAddress; newTraced[tIdx].internalID = s->internalID; newTraced[tIdx].size = size; tIdx++; }
-            }
-        }
-        SignalExecuteInfo* oldForced = nextSet.forcedSignals; SignalExecuteInfo* oldTraced = nextSet.tracedSignals;
-        nextSet.forcedSignals = newForced; nextSet.tracedSignals = newTraced; nextSet.numForced = forcedCount; nextSet.numTraced = tracedCount;
-        Atomic::Exchange((int32*)&brokers[i].currentSetIdx, (int32)nextIdx);
-        if (brokers[i].anyActiveFlag) *(brokers[i].anyActiveFlag) = (forcedCount > 0 || tracedCount > 0);
-        if (oldForced) delete[] oldForced; if (oldTraced) delete[] oldTraced;
-    }
-}
-
-DebugSignalInfo* DebugService::RegisterSignal(void* memoryAddress, TypeDescriptor type, const char8* name) {
-    mutex.FastLock();
-    DebugSignalInfo* res = NULL_PTR(DebugSignalInfo*); uint32 sigIdx = 0xFFFFFFFF;
-    for (uint32 i=0; i<numberOfAliases; i++) {
-        if (aliases[i].name == name) {
-            sigIdx = aliases[i].signalIndex; res = &signals[sigIdx];
-            if (res->memoryAddress == NULL && memoryAddress != NULL) res->memoryAddress = memoryAddress;
-            break;
-        }
-    }
-    if (res == NULL_PTR(DebugSignalInfo*) && numberOfSignals < MAX_SIGNALS) {
-        sigIdx = numberOfSignals; res = &signals[numberOfSignals];
-        res->memoryAddress = memoryAddress; res->type = type; res->name = name; 
-        res->isTracing = false; res->isForcing = false; res->internalID = numberOfSignals;
-        res->decimationFactor = 1; res->decimationCounter = 0; numberOfSignals++;
-    }
-    if (sigIdx != 0xFFFFFFFF && numberOfAliases < MAX_ALIASES) {
-        bool foundAlias = false;
-        for (uint32 i=0; i<numberOfAliases; i++) { if (aliases[i].name == name) { foundAlias = true; break; } }
-        if (!foundAlias) { aliases[numberOfAliases].name = name; aliases[numberOfAliases].signalIndex = sigIdx; numberOfAliases++; }
-    }
-    mutex.FastUnLock(); return res;
-}
-
-static void RecursivePopulate(ReferenceContainer *container, DebugService* service) {
-    if (!container) return;
-    for (uint32 i=0; i<container->Size(); i++) {
-        Reference child = container->Get(i);
-        if (child.IsValid()) {
-            DataSourceI *ds = dynamic_cast<DataSourceI*>(child.operator->());
-            if (ds) {
-                StreamString dsPath;
-                if (DebugService::GetFullObjectName(*ds, dsPath)) {
-                    for (uint32 j=0; j<ds->GetNumberOfSignals(); j++) {
-                        StreamString sname; (void)ds->GetSignalName(j, sname);
-                        StreamString fullName = dsPath; fullName += "."; fullName += sname;
-                        service->RegisterSignal(NULL, ds->GetSignalType(j), fullName.Buffer());
-                    }
-                }
-            }
-            ReferenceContainer *inner = dynamic_cast<ReferenceContainer*>(child.operator->());
-            if (inner) RecursivePopulate(inner, service);
-        }
-    }
-}
-
-void DebugService::Discover(BasicTCPSocket *client) {
-    if (client) {
-        RecursivePopulate(ObjectRegistryDatabase::Instance(), this);
-        StreamString json; json = "{\n \"Signals\": [\n";
-        mutex.FastLock();
-        for (uint32 i = 0; i < numberOfAliases; i++) {
-            DebugSignalInfo &sig = signals[aliases[i].signalIndex];
-            const char8* typeName = TypeDescriptor::GetTypeNameFromTypeDescriptor(sig.type);
-            StreamString line;
-            line.Printf("  {\"name\": \"%s\", \"id\": %u, \"type\": \"%s\", \"ready\": %s}", 
-                aliases[i].name.Buffer(), sig.internalID, typeName ? typeName : "Unknown", (sig.memoryAddress != NULL) ? "true" : "false");
-            json += line; if (i < numberOfAliases - 1) json += ","; json += "\n";
-        }
-        mutex.FastUnLock();
-        json += " ]\n}\nOK DISCOVER\n"; uint32 s = json.Size(); (void)client->Write(json.Buffer(), s);
-    }
 }
 
 void DebugService::HandleCommand(StreamString cmd, BasicTCPSocket *client) {
@@ -431,7 +388,6 @@ void DebugService::HandleCommand(StreamString cmd, BasicTCPSocket *client) {
         else if (token == "LS") {
             StreamString path; if (cmd.GetToken(path, delims, term)) ListNodes(path.Buffer(), client); else ListNodes(NULL_PTR(const char8*), client);
         }
-        UpdateBrokersActiveStatus();
     }
 }
 
@@ -515,4 +471,65 @@ uint32 DebugService::ExportTree(ReferenceContainer *container, StreamString &jso
     return validCount;
 }
 
+uint32 DebugService::ForceSignal(const char8* name, const char8* valueStr) {
+    mutex.FastLock(); uint32 count = 0;
+    for (uint32 i = 0; i < numberOfAliases; i++) {
+        if (aliases[i].name == name || SuffixMatch(aliases[i].name.Buffer(), name)) {
+            DebugSignalInfo &s = signals[aliases[i].signalIndex]; s.isForcing = true;
+            AnyType dest(s.type, 0u, s.forcedValue); AnyType source(CharString, 0u, valueStr); (void)TypeConvert(dest, source);
+            count++;
+        }
+    }
+    UpdateBrokersActiveStatus();
+    mutex.FastUnLock(); return count;
+}
+
+uint32 DebugService::UnforceSignal(const char8* name) {
+    mutex.FastLock(); uint32 count = 0;
+    for (uint32 i = 0; i < numberOfAliases; i++) {
+        if (aliases[i].name == name || SuffixMatch(aliases[i].name.Buffer(), name)) { signals[aliases[i].signalIndex].isForcing = false; count++; }
+    }
+    UpdateBrokersActiveStatus();
+    mutex.FastUnLock(); return count;
+}
+
+uint32 DebugService::TraceSignal(const char8* name, bool enable, uint32 decimation) {
+    mutex.FastLock(); uint32 count = 0;
+    for (uint32 i = 0; i < numberOfAliases; i++) {
+        if (aliases[i].name == name || SuffixMatch(aliases[i].name.Buffer(), name)) {
+            DebugSignalInfo &s = signals[aliases[i].signalIndex]; s.isTracing = enable; s.decimationFactor = decimation; s.decimationCounter = 0; count++;
+            printf("[Debug] Tracing state for %s (ID: %u) set to %d\n", aliases[i].name.Buffer(), s.internalID, enable);
+        }
+    }
+    UpdateBrokersActiveStatus();
+    mutex.FastUnLock(); return count;
+}
+
+void DebugService::Discover(BasicTCPSocket *client) {
+    if (client) {
+        StreamString header = "{\n \"Signals\": [\n"; uint32 s = header.Size(); (void)client->Write(header.Buffer(), s);
+        mutex.FastLock();
+        for (uint32 i = 0; i < numberOfAliases; i++) {
+            StreamString line; DebugSignalInfo &sig = signals[aliases[i].signalIndex];
+            const char8* typeName = TypeDescriptor::GetTypeNameFromTypeDescriptor(sig.type);
+            line.Printf("  {\"name\": \"%s\", \"id\": %d, \"type\": \"%s\"}", aliases[i].name.Buffer(), sig.internalID, typeName ? typeName : "Unknown");
+            if (i < numberOfAliases - 1) line += ",";
+            line += "\n"; s = line.Size(); (void)client->Write(line.Buffer(), s);
+        }
+        mutex.FastUnLock();
+        StreamString footer = " ]\n}\nOK DISCOVER\n"; s = footer.Size(); (void)client->Write(footer.Buffer(), s);
+    }
+}
+
+void DebugService::ListNodes(const char8* path, BasicTCPSocket *client) {
+    if (!client) return;
+    Reference ref = (path == NULL_PTR(const char8*) || StringHelper::Length(path) == 0 || StringHelper::Compare(path, "/") == 0) ? ObjectRegistryDatabase::Instance() : ObjectRegistryDatabase::Instance()->Find(path);
+    if (ref.IsValid()) {
+        StreamString out; out.Printf("Nodes under %s:\n", path ? path : "/");
+        ReferenceContainer *container = dynamic_cast<ReferenceContainer*>(ref.operator->());
+        if (container) { for (uint32 i=0; i<container->Size(); i++) { Reference child = container->Get(i); if (child.IsValid()) out.Printf("  %s [%s]\n", child->GetName(), child->GetClassProperties()->GetName()); } }
+        const char* okMsg = "OK LS\n"; out += okMsg; uint32 s = out.Size(); (void)client->Write(out.Buffer(), s);
+    } else { const char* msg = "ERROR: Path not found\n"; uint32 s = StringHelper::Length(msg); (void)client->Write(msg, s); }
+}
+
 }

Test/Configurations/debug_test.cfg

@@ -1,19 +1,3 @@
-+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 = {
@@ -136,3 +120,19 @@
         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

@@ -1,109 +0,0 @@
-#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,12 +9,3 @@ 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

@@ -1,217 +0,0 @@
-#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

@@ -1,109 +0,0 @@
-#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/UnitTests/main.cpp

@@ -51,15 +51,18 @@ public:
         service.HandleCommand("RESUME", NULL_PTR(BasicTCPSocket*));
         service.HandleCommand("LS /", NULL_PTR(BasicTCPSocket*));
         
-        // 3. Broker Active Status (Wait-Free)
+        // 3. Broker Active Status
         volatile bool active = false;
+        Vector<uint32> indices;
+        Vector<uint32> sizes;
+        FastPollingMutexSem mutex;
         DebugSignalInfo* ptrs[1] = { &service.signals[0] };
-        service.RegisterBroker(ptrs, 1, NULL_PTR(MemoryMapBroker*), &active);
+        service.RegisterBroker(ptrs, 1, NULL_PTR(MemoryMapBroker*), &active, &indices, &sizes, &mutex);
         service.UpdateBrokersActiveStatus();
         assert(active == true);
         
         // Helper Process
-        DebugBrokerHelper::Process(&service, service.brokers[0]);
+        DebugBrokerHelper::Process(&service, ptrs, indices, sizes, mutex);
 
         // 4. Object Hierarchy branches
         service.HandleCommand("INFO X.Y.Z", NULL_PTR(BasicTCPSocket*));
@@ -95,6 +98,7 @@ void TestRingBuffer() {
 int main(int argc, char **argv) {
     printf("--- MARTe2 Debug Suite COVERAGE V29 ---\n");
     MARTe::TestTcpLogger();
+    // MARTe::TestRingBuffer(); // Fixed previously, but let's keep it clean
     MARTe::DebugServiceTest::TestAll();
     printf("\nCOVERAGE V29 PASSED!\n");
     return 0;

Tools/gui_client/src/main.rs

@@ -342,7 +342,7 @@ fn tcp_command_worker(shared_config: Arc<Mutex<ConnectionConfig>>, rx_cmd: Recei
                     let trimmed = line.trim();
                     if trimmed.is_empty() { line.clear(); continue; }
                     
-                    if !in_json && (trimmed.starts_with("{") || trimmed.starts_with("[")) { in_json = true; json_acc.clear(); }
+                    if !in_json && trimmed.starts_with("{") { in_json = true; json_acc.clear(); }
                     
                     if in_json {
                         json_acc.push_str(trimmed);
@@ -439,7 +439,6 @@ fn udp_worker(shared_config: Arc<Mutex<ConnectionConfig>>, id_to_meta: Arc<Mutex
     let mut socket: Option<UdpSocket> = None;
     let mut last_seq: Option<u32> = None;
     let mut last_warning_time = std::time::Instant::now();
-    let mut first_packet = true;
     
     loop {
         let (ver, port) = { let config = shared_config.lock().unwrap(); (config.version, config.udp_port.clone()) };
@@ -461,7 +460,6 @@ fn udp_worker(shared_config: Arc<Mutex<ConnectionConfig>>, id_to_meta: Arc<Mutex
             if !bound { thread::sleep(std::time::Duration::from_secs(5)); continue; }
             let _ = socket.as_ref().unwrap().set_read_timeout(Some(std::time::Duration::from_millis(500)));
             last_seq = None;
-            first_packet = true;
         }
         let s = if let Some(sock) = socket.as_ref() { sock } else { thread::sleep(std::time::Duration::from_secs(1)); continue; };
         let mut buf = [0u8; 4096];
@@ -470,14 +468,9 @@ fn udp_worker(shared_config: Arc<Mutex<ConnectionConfig>>, id_to_meta: Arc<Mutex
             if shared_config.lock().unwrap().version != current_version { break; }
             if let Ok(n) = s.recv(&mut buf) {
                 total_packets += 1;
-                if (total_packets % 10) == 0 { let _ = tx_events.send(InternalEvent::UdpStats(total_packets)); }
+                if (total_packets % 500) == 0 { let _ = tx_events.send(InternalEvent::UdpStats(total_packets)); }
-                if first_packet {
-                    let _ = tx_events.send(InternalEvent::InternalLog("First UDP packet received!".to_string()));
-                    first_packet = false;
-                }
                 if n < 20 { continue; }
-                let magic = u32::from_le_bytes(buf[0..4].try_into().unwrap());
+                if u32::from_le_bytes(buf[0..4].try_into().unwrap()) != 0xDA7A57AD { continue; }
-                if magic != 0xDA7A57AD { continue; }
                 let seq = u32::from_le_bytes(buf[4..8].try_into().unwrap());
                 if let Some(last) = last_seq { if seq != last + 1 && seq > last { let _ = tx_events.send(InternalEvent::UdpDropped(seq - last - 1)); } }
                 last_seq = Some(seq);
@@ -489,7 +482,7 @@ fn udp_worker(shared_config: Arc<Mutex<ConnectionConfig>>, id_to_meta: Arc<Mutex
                 let metas = id_to_meta.lock().unwrap();
                 
                 if metas.is_empty() && count > 0 && last_warning_time.elapsed().as_secs() > 5 {
-                    let _ = tx_events.send(InternalEvent::InternalLog(format!("UDP received but Metadata empty ({} known). Still discovering?", metas.len())));
+                    let _ = tx_events.send(InternalEvent::InternalLog("UDP received but Metadata empty. Still discovering?".to_string()));
                     last_warning_time = std::time::Instant::now();
                 }
 
@@ -504,43 +497,24 @@ fn udp_worker(shared_config: Arc<Mutex<ConnectionConfig>>, id_to_meta: Arc<Mutex
                     let data_slice = &buf[offset..offset + size as usize];
                     
                     let mut base_ts_guard = BASE_TELEM_TS.lock().unwrap();
-                    
-                    if let Some(base) = *base_ts_guard {
-                        let diff = if ts_raw > base { ts_raw - base } else { base - ts_raw };
-                        if diff > 100_000_000 {
-                            *base_ts_guard = Some(ts_raw);
-                            let _ = tx_events.send(InternalEvent::InternalLog("Clock reset detected. Syncing base.".to_string()));
-                        }
-                    }
-                    
                     if base_ts_guard.is_none() { *base_ts_guard = Some(ts_raw); }
                     
                     let base = base_ts_guard.unwrap();
                     let ts_s = if ts_raw >= base {
                         (ts_raw - base) as f64 / 1000000.0
                     } else {
-                        0.0
+                        0.0 // Avoid huge jitter wrap-around
                     };
                     drop(base_ts_guard);
 
                     if let Some(meta) = metas.get(&id) {
                         let _ = tx_events.send(InternalEvent::TelemMatched(id));
-                        let t = meta.sig_type.to_lowercase();
+                        let t = meta.sig_type.as_str();
                         let val = match size {
                             1 => { if t.contains('u') { data_slice[0] as f64 } else { (data_slice[0] as i8) as f64 } },
                             2 => { let b = data_slice[0..2].try_into().unwrap(); if t.contains('u') { u16::from_le_bytes(b) as f64 } else { i16::from_le_bytes(b) as f64 } },
-                            4 => { 
+                            4 => { let b = data_slice[0..4].try_into().unwrap(); if t.contains("float") { f32::from_le_bytes(b) as f64 } else if t.contains('u') { u32::from_le_bytes(b) as f64 } else { i32::from_le_bytes(b) as f64 } },
-                                let b = data_slice[0..4].try_into().unwrap(); 
+                            8 => { let b = data_slice[0..8].try_into().unwrap(); if t.contains("float") { f64::from_le_bytes(b) } else if t.contains('u') { u64::from_le_bytes(b) as f64 } else { i64::from_le_bytes(b) as f64 } },
-                                if t.contains("float") || (t.contains("32") && (t.contains('f') || t.contains("real"))) { f32::from_le_bytes(b) as f64 } 
-                                else if t.contains('u') { u32::from_le_bytes(b) as f64 } 
-                                else { i32::from_le_bytes(b) as f64 } 
-                            },
-                            8 => { 
-                                let b = data_slice[0..8].try_into().unwrap(); 
-                                if t.contains("float") || t.contains("double") || (t.contains("64") && (t.contains('f') || t.contains("real"))) { f64::from_le_bytes(b) } 
-                                else if t.contains('u') { u64::from_le_bytes(b) as f64 } 
-                                else { i64::from_le_bytes(b) as f64 } 
-                            },
                             _ => 0.0,
                         };
                         for name in &meta.names { 
@@ -728,16 +702,6 @@ impl eframe::App for MarteDebugApp {
                     }
                 });
                 ui.separator();
-                ui.heading("Telemetry Stats");
-                let mut ids: Vec<_> = self.telem_match_count.keys().cloned().collect();
-                ids.sort();
-                if ids.is_empty() { ui.label("No IDs matched yet."); }
-                for id in ids {
-                    if let Some(count) = self.telem_match_count.get(&id) {
-                        ui.label(format!("ID {}: {} samples", id, count));
-                    }
-                }
-                ui.separator();
                 ui.heading("Forced Signals");
                 for (path, val) in &self.forced_signals { ui.horizontal(|ui| { ui.label(format!("{}: {}", path, val)); if ui.button("❌").clicked() { let _ = self.tx_cmd.send(format!("UNFORCE {}", path)); } }); }
             });

Tools/pipeline_validator/Cargo.lock

@@ -1,431 +0,0 @@
-# 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

@@ -1,10 +0,0 @@
-[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

@@ -1,135 +0,0 @@
-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,6 +17,17 @@ 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
@@ -32,90 +43,53 @@ 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
-[Information] Creating broker MemoryMapSynchronisedInputBroker for GAM2 and signal Counter(0)
+[Debug] Purging dataSourcesIndexesCache. Number of children:3
-[DebugBrokerBuilder] Built MemoryMapSynchronisedInputBroker
+[Debug] Purging functionsIndexesCache. Number of children:1
-[Debug] Purging dataSourcesIndexesCache. Number of children:4
+[Debug] Purging dataSourcesSignalIndexCache. Number of children:3
-[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:1
+[Debug] Purging functionsMemoryIndexesCache. Number of children:2
 [Debug] Purged functionsMemoryIndexesCache. Number of children:0
 [Debug] Purged cachedIntrospections. Number of children:0
 [Information] Going to rtAppBuilder.PostConfigureDataSources()
@@ -128,11 +102,6 @@ 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
@@ -142,253 +111,40 @@ Filename = "Test/Configurations/debug_
 [Information] Going to FindStatefulDataSources
 [Information] Going to configure scheduler
 [Information] Preparing state State1 
-[Information] Frequency found = 1000.000000
+[Information] Frequency found = 1.000000
-[Information] Frequency found = 1000.000000
+[Information] Frequency found = 1.000000
-[Information] The timer will be set using a frequency of 1000.000000 Hz
+[Information] The timer will be set using a frequency of 1.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
-./run_debug_app.sh: line 40: 325075 Killed                     "$MARTE_EX" -f Test/Configurations/debug_test.cfg -l RealTimeLoader -s State1
+[Information] Time [0:0]:12000000
+[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

@@ -1,30 +0,0 @@
-#!/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:${LD_LIBRARY_PATH}"
+export LD_LIBRARY_PATH="$(pwd)/Build:${MARTe2_DIR}/Build/${TARGET}/Core:${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="$(pwd)/Build/libmarte_dev.so"
+export LD_PRELOAD="${DEBUG_LIB}"
 "$MARTE_EX" -f Test/Configurations/debug_test.cfg -l RealTimeLoader -s State1

specs.md

@@ -1,41 +0,0 @@
-Project Specification: MARTe2 Universal Observability & Debugging Suite
-
-Version: 1.1
-
-Date: 2023-10-27
-
-Status: Active / Implemented
-
-1. Executive Summary
-
-This project implements a "Zero-Code-Change" observability and debugging layer for the MARTe2 real-time framework. The system allows developers to Trace, Force, and Monitor any signal in a running MARTe2 application without modifying existing source code.
-
-2. System Architecture
-
-- The Universal Debug Service (C++ Core): A singleton MARTe2 Object that patches the registry and manages communication.
-- The Broker Injection Layer (C++ Templates): Templated wrappers that intercept Copy() calls for tracing, forcing, and execution control.
-- The Remote Analyser (Rust/egui): A high-performance, multi-threaded GUI for visualization and control.
-
-3. Functional Requirements
-
-3.1 Execution Control
-- REQ-25: Execution Control (Pause/Resume): The system SHALL provide a mechanism to pause and resume the execution of all patched real-time threads (via Brokers), allowing for static inspection of the system state.
-
-3.2 Discovery
-- REQ-24: Tree Exploration: The GUI client SHALL request the full application tree upon connection and display it in a hierarchical tree view.
-- TREE Command: Returns a recursive JSON structure representing the entire application tree, including signal metadata (Type, Dimensions, Elements).
-
-3.3 Multi-Threaded Client (REQ-23)
-- Port 8080 (TCP): Commands and Metadata.
-- Port 8082 (TCP): Independent Real-Time Log Stream.
-- Port 8081 (UDP): High-Speed Telemetry for Oscilloscope.
-
-4. Communication Protocol
-
-- LS [Path]: List nodes.
-- TREE: Full recursive JSON application map.
-- PAUSE / RESUME: Execution control.
-- TRACE <Signal> <1/0> [Decimation]: Telemetry control.
-- FORCE <Signal> <Value>: Persistent signal override.
-- UNFORCE <Signal>: Remove override.
-- LOG <Level> <Msg>: Port 8082 streaming format.